qsu 0.5.5 → 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+declare interface LicenseOption {
+    author: string;
+    email?: string;
+    yearStart: string | number;
+    yearEnd?: string;
+    htmlBr?: boolean;
+    type: 'mit' | 'apache20';
+}
+declare type PositiveNumber<N extends number> = number extends N ? N : `${N}` extends `-${string}` ? never : N;
+export default class Qsu {
+    static sleep<N extends number>(delay: PositiveNumber<N>): Promise<void>;
+    static numRandom(min: number, max: number): number;
+    static sum(...args: number[]): number;
+    static mul(...args: number[]): number;
+    static dayDiff(date1: Date, date2?: Date): number;
+    static today(dateFormat?: string): string;
+    static isRealDate(date: string | Date): boolean;
+    static convertDate(date: string, format?: string): string;
+    static arrShuffle(array: any[]): any[];
+    static arrWithDefault(defaultValue: any, length?: number): any[];
+    static arrUnique(array: any[]): any[];
+    static arrWithNumber(start: number, end: number): number[];
+    static average(array: number[]): number;
+    static arrMove<N extends number>(array: any[], from: PositiveNumber<N>, to: PositiveNumber<N>): any[];
+    static removeSpecialChar(str: string, withoutSpace?: boolean): string;
+    static removeNewLine(str: string, replaceTo?: string): string;
+    static capitalizeFirst(str: string): string;
+    static capitalizeEachWords(str: string, natural?: boolean): string;
+    static strNumberOf(str: string, search: string): number;
+    static strShuffle(str: string): string;
+    static strRandom<N extends number>(length: PositiveNumber<N>, additionalCharacters?: string): string;
+    static strBlindRandom<N extends number>(str: string, blindLength: PositiveNumber<N>, blindStr?: string): string;
+    static truncate<N extends number>(str: string, length: PositiveNumber<N>, ellipsis?: string): string;
+    static encrypt(str: string, secret: string, algorithm?: string, ivSize?: number): string;
+    static decrypt(str: string, secret: string, algorithm?: string): string;
+    static md5(str: string): string;
+    static sha1(str: string): string;
+    static sha256(str: string): string;
+    static encodeBase64(str: string): string;
+    static decodeBase64(encodedStr: string): string;
+    static strUnique(str: string): string;
+    static isEmpty(data?: any): boolean;
+    static isUrl(url: string, withProtocol?: boolean, strict?: boolean): boolean;
+    static contains(str: any[] | string, search: any[] | string, exact?: boolean): boolean;
+    static is2dArray(array: any[]): boolean;
+    static between(range: [number, number], number: number, inclusive?: boolean): boolean;
+    static len(data: any): number;
+    static isBotAgent(userAgent: string): boolean;
+    static numberFormat(number: number): string;
+    static fileName(filePath: string, withExtension?: boolean): string;
+    static fileSize<N extends number>(bytes: PositiveNumber<N>, decimals?: number): string;
+    static fileExt(filePath: string): string;
+    static msToTime(milliseconds?: number, withMilliseconds?: boolean, separator?: string): string;
+    static secToTime(seconds?: number, onlyHour?: boolean, separator?: string): string;
+    static license(options: LicenseOption): string;
+}
+export { Qsu, };

package/dist/index.js

@@ -0,0 +1,349 @@
+import moment from 'moment';
+import path from 'path';
+import crypto from 'crypto';
+export default class Qsu {
+    /*
+    * Misc
+    * */
+    static sleep(delay) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, delay);
+        });
+    }
+    /*
+    * Math
+    * */
+    static numRandom(min, max) {
+        if (!min && !max) {
+            return (Math.random() > 0.5) ? 1 : 0;
+        }
+        const limit = !max ? min : max;
+        const offset = (!max || min >= max) ? null : min;
+        return Math.floor(Math.random() * (offset ? (limit - offset + 1) : limit + 1)) + (offset || 0);
+    }
+    static sum(...args) {
+        const val = args.length > 0 && typeof args[0] === 'object' ? args[0] : args;
+        let total = 0;
+        for (let i = 0, iLen = val.length; i < iLen; i += 1) {
+            if (typeof val[i] === 'number') {
+                total += val[i];
+            }
+        }
+        return total;
+    }
+    static mul(...args) {
+        const val = args.length > 0 && typeof args[0] === 'object' ? args[0] : args;
+        let total = val[0];
+        for (let i = 1, iLen = val.length; i < iLen; i += 1) {
+            if (typeof val[i] === 'number') {
+                total *= val[i];
+            }
+        }
+        return total;
+    }
+    /*
+    * Date
+    * */
+    static dayDiff(date1, date2) {
+        const date2c = date2 || new Date();
+        return Math.ceil(Math.abs(date2c.getTime() - date1.getTime()) / (1000 * 3600 * 24));
+    }
+    static today(dateFormat) {
+        return moment().format(dateFormat || 'YYYY-MM-DD');
+    }
+    static isRealDate(date) {
+        const dateConverted = typeof date === 'string' ? new Date(date) : date;
+        if (!dateConverted.getTime()) {
+            return false;
+        }
+        return dateConverted.toISOString().slice(0, 10) === date;
+    }
+    static convertDate(date, format) {
+        return moment(date).format(format || 'YYYY-MM-DD');
+    }
+    /*
+    * Array
+    * */
+    static arrShuffle(array) {
+        if (array.length === 1) {
+            return array[0];
+        }
+        const newArray = array;
+        for (let i = array.length - 1; i > 0; i -= 1) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [newArray[i], newArray[j]] = [array[j], array[i]];
+        }
+        return newArray;
+    }
+    static arrWithDefault(defaultValue, length = 0) {
+        if (length < 1) {
+            return [];
+        }
+        return Array(length).fill(defaultValue);
+    }
+    static arrUnique(array) {
+        if (this.is2dArray(array)) {
+            return array.map((x) => JSON.stringify(x))
+                .reverse()
+                .filter((e, i, a) => a.indexOf(e, i + 1) === -1)
+                .reverse()
+                .map((x) => JSON.parse(x));
+        }
+        return [...new Set(array)];
+    }
+    static arrWithNumber(start, end) {
+        if (start > end) {
+            throw new Error('end is greater than start.');
+        }
+        return Array.from({ length: (end - start) + 1 }, (_, i) => i + start);
+    }
+    static average(array) {
+        return array.reduce((p, c) => p + c, 0) / array.length;
+    }
+    static arrMove(array, from, to) {
+        const arrayLength = array.length;
+        if (arrayLength <= from || arrayLength <= to) {
+            throw new Error('Invalid move params');
+        }
+        array.splice(to, 0, array.splice(from, 1)[0]);
+        return array;
+    }
+    /*
+    * String
+    * */
+    static removeSpecialChar(str, withoutSpace) {
+        return str.replace(new RegExp(`[^a-zA-Z가-힣ㄱ-ㅎㅏ-ㅣ0-9\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff66-\uff9f${withoutSpace ? ' ' : ''}]`, 'gi'), '');
+    }
+    static removeNewLine(str, replaceTo = '') {
+        return str.replace(/(\r\n|\n|\r)/gm, replaceTo).trim();
+    }
+    static capitalizeFirst(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    static capitalizeEachWords(str, natural) {
+        const splitStr = str.trim().toLowerCase().split(' ');
+        for (let i = 0, iLen = splitStr.length; i < iLen; i += 1) {
+            if (!natural || !this.contains(splitStr[i], [
+                'in', 'on', 'the', 'at', 'and', 'or', 'of', 'for', 'to', 'that',
+                'a', 'by', 'it', 'is', 'as', 'are', 'were', 'was', 'nor', 'an',
+            ], true)) {
+                splitStr[i] = this.capitalizeFirst(splitStr[i]);
+            }
+        }
+        return this.capitalizeFirst(splitStr.join(' '));
+    }
+    static strNumberOf(str, search) {
+        return (str.match(new RegExp(search, 'g')) || []).length;
+    }
+    static strShuffle(str) {
+        return [...str].sort(() => Math.random() - 0.5).join('');
+    }
+    static strRandom(length, additionalCharacters) {
+        const availCharacters = `abcdefghijklmnopqrstuvwxyz0123456789${additionalCharacters}`;
+        const availCharacterLength = availCharacters.length;
+        let result = '';
+        let newChar;
+        for (let i = 0; i < length; i += 1) {
+            newChar = availCharacters.charAt(Math.floor(Math.random() * availCharacterLength));
+            newChar = Math.random() < 0.5 ? newChar.toUpperCase() : newChar;
+            result += newChar;
+        }
+        return result;
+    }
+    static strBlindRandom(str, blindLength, blindStr = '*') {
+        let currentStr = str;
+        let hideCount = 0;
+        let tempIdx = 0;
+        let currentStrLength = 0;
+        const totalStrLength = currentStr.length;
+        while ((hideCount < blindLength) && (currentStrLength < totalStrLength)) {
+            tempIdx = this.numRandom(0, totalStrLength);
+            if (/[a-zA-Z가-힣]/.test(currentStr.substring(tempIdx, tempIdx + 1))) {
+                currentStr = `${currentStr.substring(0, tempIdx + 1)}${blindStr}${currentStr.substring(tempIdx + 2)}`;
+                hideCount += 1;
+            }
+            currentStrLength += 1;
+        }
+        return currentStr;
+    }
+    static truncate(str, length, ellipsis = '') {
+        let convStr = str;
+        if (str.length > length) {
+            convStr = str.substring(0, length) + ellipsis;
+        }
+        return convStr;
+    }
+    static encrypt(str, secret, algorithm = 'aes-256-cbc', ivSize = 16) {
+        if (str.length < 1) {
+            return '';
+        }
+        const iv = crypto.randomBytes(ivSize);
+        const cipher = crypto.createCipheriv(algorithm, secret, iv);
+        let enc = cipher.update(str);
+        enc = Buffer.concat([enc, cipher.final()]);
+        return `${iv.toString('hex')}:${enc.toString('hex')}`;
+    }
+    static decrypt(str, secret, algorithm = 'aes-256-cbc') {
+        if (str.length < 1) {
+            return '';
+        }
+        const arrStr = str.split(':');
+        const decipher = crypto.createDecipheriv(algorithm, secret, Buffer.from(arrStr.shift(), 'hex'));
+        let decrypted = decipher.update(Buffer.from(arrStr.join(':'), 'hex'));
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted.toString();
+    }
+    static md5(str) {
+        return crypto.createHash('md5').update(str).digest('hex');
+    }
+    static sha1(str) {
+        return crypto.createHash('sha1').update(str).digest('hex');
+    }
+    static sha256(str) {
+        return crypto.createHash('sha256').update(str).digest('hex');
+    }
+    static encodeBase64(str) {
+        return Buffer.from(str, 'utf8').toString('base64');
+    }
+    static decodeBase64(encodedStr) {
+        return Buffer.from(encodedStr, 'base64').toString('utf8');
+    }
+    static strUnique(str) {
+        return [...new Set(str)].join('');
+    }
+    /*
+    * Verify
+    * */
+    static isEmpty(data) {
+        if (!data) {
+            return true;
+        }
+        switch (typeof data) {
+            case 'string':
+                return data.length < 1;
+            case 'object':
+                if (Array.isArray(data)) {
+                    return data.length < 1;
+                }
+                return Object.keys(data).length < 1;
+            default:
+                return false;
+        }
+    }
+    static isUrl(url, withProtocol = false, strict = false) {
+        if (strict && url.indexOf('.') === -1) {
+            return false;
+        }
+        try {
+            new URL(`${(withProtocol && url.indexOf('://') === -1) ? 'https://' : ''}${url}`).toString();
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    static contains(str, search, exact = false) {
+        if (typeof search === 'string') {
+            return str.indexOf(search) !== -1;
+        }
+        for (let i = 0, iLen = search.length; i < iLen; i += 1) {
+            if (exact) {
+                if (str === search[i]) {
+                    return true;
+                }
+            }
+            else if (str.indexOf(search[i]) !== -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static is2dArray(array) {
+        return array.filter(Array.isArray).length > 0;
+    }
+    static between(range, number, inclusive = false) {
+        const minM = Math.min.apply(Math, [range[0], range[1]]);
+        const maxM = Math.max.apply(Math, [range[0], range[1]]);
+        return inclusive ? number >= minM && number <= maxM : number > minM && number < maxM;
+    }
+    static len(data) {
+        if (!data) {
+            return 0;
+        }
+        switch (typeof data) {
+            case 'object':
+                return Array.isArray(data) ? data.length : Object.keys(data).length;
+            case 'number':
+            case 'bigint':
+                return data.toString().length;
+            case 'boolean':
+                return data ? 4 : 5;
+            case 'function':
+                return data().length;
+            case 'string':
+            default:
+                return data.length;
+        }
+    }
+    static isBotAgent(userAgent) {
+        return /bot|naverbot|google|Googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google|bingbot|slurp|java|wget|curl|Commons-HttpClient|Python-urllib|libwww|httpunit|nutch|phpcrawl|msnbot|jyxobot|FAST-WebCrawler|FAST Enterprise Crawler|biglotron|teoma|convera|seekbot|gigablast|exabot|ngbot|ia_archiver|GingerCrawler|webmon |httrack|webcrawler|grub.org|UsineNouvelleCrawler|antibot|netresearchserver|speedy|fluffy|bibnum.bnf|findlink|msrbot|panscient|yacybot|AISearchBot|IOI|ips-agent|tagoobot|MJ12bot|dotbot|woriobot|yanga|buzzbot|mlbot|yandexbot|purebot|Linguee Bot|Voyager|CyberPatrol|voilabot|baiduspider|citeseerxbot|spbot|twengabot|postrank|turnitinbot|scribdbot|page2rss|sitebot|linkdex|Adidxbot|blekkobot|ezooms|dotbot|Mail.RU_Bot|discobot|heritrix|findthatfile|europarchive.org|NerdByNature.Bot|sistrix crawler|ahrefsbot|Aboundex|domaincrawler|wbsearchbot|summify|ccbot|edisterbot|seznambot|ec2linkfinder|gslfbot|aihitbot|intelium_bot|facebookexternalhit|yeti|RetrevoPageAnalyzer|lb-spider|sogou|lssbot|careerbot|wotbox|wocbot|ichiro|DuckDuckBot|lssrocketcrawler|drupact|webcompanycrawler|acoonbot|openindexspider|gnam gnam spider|web-archive-net.com.bot|backlinkcrawler|coccoc|integromedb|content crawler spider|toplistbot|seokicks-robot|it2media-domain-crawler|ip-web-crawler.com|siteexplorer.info|elisabot|proximic|changedetection|blexbot|arabot|WeSEE:Search|niki-bot|CrystalSemanticsBot|rogerbot|360Spider|psbot|InterfaxScanBot|Lipperhey SEO Service|CC Metadata Scaper|g00g1e.net|GrapeshotCrawler|urlappendbot|brainobot|fr-crawler|binlar|SimpleCrawler|Livelapbot|Twitterbot|cXensebot|smtbot|bnf.fr_bot|A6-Indexer|ADmantX|Facebot|Twitterbot|OrangeBot|memorybot|AdvBot|MegaIndex|SemanticScholarBot|ltx71|nerdybot|xovibot|BUbiNG|Qwantify|archive.org_bot|Applebot|TweetmemeBot|crawler4j|findxbot|SemrushBot|yoozBot|lipperhey|y!j-asr|Domain Re-Animator Bot|AddThis/i.test(userAgent);
+    }
+    /*
+    * Format
+    * */
+    static numberFormat(number) {
+        return new Intl.NumberFormat().format(number);
+    }
+    static fileName(filePath, withExtension = false) {
+        if (withExtension) {
+            return path.basename(filePath);
+        }
+        return path.basename(filePath, path.extname(filePath));
+    }
+    static fileSize(bytes, decimals = 2) {
+        if (bytes === 0 || bytes < 0) {
+            return '0 Bytes';
+        }
+        const byteCalc = Math.floor(Math.log(bytes) / Math.log(1024));
+        return `${parseFloat((bytes / 1024 ** byteCalc).toFixed((decimals < 0 ? 0 : decimals)))} ${['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'][byteCalc]}`;
+    }
+    static fileExt(filePath) {
+        if (filePath.indexOf('.') === -1) {
+            return 'Unknown';
+        }
+        const pSpl = filePath.trim().toLowerCase().split('.');
+        return pSpl.length > 0 ? pSpl[pSpl.length - 1] : 'Unknown';
+    }
+    static msToTime(milliseconds = 0, withMilliseconds = false, separator = ':') {
+        const ms = Math.floor((milliseconds % 1000) / 100);
+        let sec = Math.floor((milliseconds / 1000) % 60);
+        let min = Math.floor((milliseconds / (1000 * 60)) % 60);
+        let hour = Math.floor(milliseconds / (1000 * 60 * 60));
+        hour = (hour < 10) ? `0${hour}` : hour;
+        min = (min < 10) ? `0${min}` : min;
+        sec = (sec < 10) ? `0${sec}` : sec;
+        return `${hour}${separator}${min}${separator}${sec}${withMilliseconds ? `.${ms}` : ''}`;
+    }
+    static secToTime(seconds = 0, onlyHour = false, separator = ':') {
+        let sec = Math.floor(seconds % 60);
+        let min = Math.floor((seconds / 60) % 60);
+        let hour = Math.floor(seconds / (60 * 60));
+        hour = (hour < 10) ? `0${hour}` : hour;
+        min = (min < 10) ? `0${min}` : min;
+        sec = (sec < 10) ? `0${sec}` : sec;
+        return onlyHour ? hour.toString() : `${hour}${separator}${min}${separator}${sec}`;
+    }
+    static license(options) {
+        const br = options.htmlBr ? '<br/>' : '\n';
+        const yearString = `${options.yearStart}${options.yearEnd ? `-${options.yearEnd}` : ''}`;
+        const authorString = `${options.author}${options.email ? ` <${options.email}>` : ''}`;
+        switch (options.type.replace(/\.-_,\s/g, '').toLowerCase()) {
+            case 'apache20':
+                return `Copyright ${yearString} ${authorString}${br}${br}Licensed under the Apache License, Version 2.0 (the "License");${br}you may not use this file except in compliance with the License.${br}You may obtain a copy of the License at${br}${br}    http://www.apache.org/licenses/LICENSE-2.0${br}${br}Unless required by applicable law or agreed to in writing, software${br}distributed under the License is distributed on an "AS IS" BASIS,${br}WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.${br}See the License for the specific language governing permissions and${br}limitations under the License.`;
+            case 'mit':
+            default:
+                return `Copyright (c) ${yearString} ${authorString}${br}${br}Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:${br}${br}The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.${br}${br}THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`;
+        }
+    }
+}
+export { Qsu, };

package/package.json

@@ -1,38 +1,55 @@
-{
-  "name": "qsu",
-  "version": "0.5.5",
-  "description": "Quick and Simple Utility for javascript",
-  "scripts": {
-    "test": "npm run lint && mocha --require @babel/register --parallel test/*.spec.js",
-    "dev": "babel-node index.js",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix ."
-  },
-  "engines": {
-    "node": ">=12.0.0"
-  },
-  "author": "Jooy2 <jootc.help@gmail.com>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/jooy2/qsu"
-  },
-  "keywords": [
-    "util",
-    "utility",
-    "tool",
-    "underscore"
-  ],
-  "devDependencies": {
-    "@babel/node": "^7.16.8",
-    "@babel/preset-env": "^7.16.11",
-    "@babel/register": "^7.17.7",
-    "eslint": "^8.13.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-plugin-import": "^2.26.0",
-    "mocha": "^9.2.2"
-  },
-  "dependencies": {
-    "moment": "^2.29.2"
-  }
-}
+{
+  "name": "qsu",
+  "version": "1.0.2",
+  "description": "Quick and Simple Utility for javascript",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run lint && npm run build && mocha --parallel test/*.spec.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "author": "Jooy2 <jootc.help@gmail.com>",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      "index.d.ts": [
+        "dist/index.d.ts"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jooy2/qsu"
+  },
+  "keywords": [
+    "util",
+    "utility",
+    "tool",
+    "underscore",
+    "website",
+    "helper"
+  ],
+  "devDependencies": {
+    "@types/node": "^17.0.35",
+    "@typescript-eslint/eslint-plugin": "^5.25.0",
+    "@typescript-eslint/parser": "^5.25.0",
+    "eslint": "^8.16.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-import": "^2.26.0",
+    "mocha": "^10.0.0",
+    "ts-node": "^10.8.0",
+    "typescript": "^4.6.4"
+  },
+  "dependencies": {
+    "moment": "^2.29.3"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "baseUrl": "lib",
+    "target": "es2020",
+    "module": "es2022",
+    "lib": [
+      "es2020"
+    ],
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true
+  },
+  "include": [
+    "lib/**/*.ts",
+    "lib/**/*.d.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts"
+  ]
+}

package/.babelrc

@@ -1,7 +0,0 @@
-{
-  "presets": [
-    [
-      "@babel/preset-env"
-    ]
-  ]
-}

package/.eslintrc.js

@@ -1,25 +0,0 @@
-module.exports = {
-  parserOptions: {
-    sourceType: 'module',
-    ecmaVersion: 2020,
-  },
-  env: {
-    node: true,
-    es6: true,
-  },
-  extends: [
-    'airbnb/base',
-  ],
-  rules: {
-    'linebreak-style': ['error', 'windows'],
-    'arrow-parens': 0,
-  },
-  overrides: [
-    {
-      files: ['test/*.spec.js'],
-      rules: {
-        'no-undef': 0,
-      },
-    },
-  ],
-};

package/.idea/git_toolbox_prj.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GitToolBoxProjectSettings">
-    <option name="commitMessageIssueKeyValidationOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-    <option name="commitMessageValidationConfigOverride">
-      <CommitMessageValidationOverride>
-        <option name="enabled" value="true" />
-      </CommitMessageValidationOverride>
-    </option>
-    <option name="commitMessageValidationEnabledOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-  </component>
-</project>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-  </profile>
-</component>

package/.idea/jsLibraryMappings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptLibraryMappings">
-    <includedPredefinedLibrary name="Node.js Core" />
-  </component>
-</project>

package/.idea/jsLinters/eslint.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EslintConfiguration">
-    <option name="fix-on-save" value="true" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/qsu.iml" filepath="$PROJECT_DIR$/.idea/qsu.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/qsu.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>