@aiou/eslint-config 0.11.2 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,4364 @@
+import { isPackageExists } from 'local-pkg';
+import pluginComments from 'eslint-plugin-eslint-comments';
+import ignoreGlobs from '@aiou/eslint-ignore';
+import pluginImport from 'eslint-plugin-i';
+import pluginImportNewlines from 'eslint-plugin-import-newlines';
+import pluginSimpleImportSort from 'eslint-plugin-simple-import-sort';
+import pluginUnsedImports from 'eslint-plugin-unused-imports';
+import pluginN from 'eslint-plugin-n';
+import pluginPromise from 'eslint-plugin-promise';
+import pluginRegexp from 'eslint-plugin-regexp';
+import globals$1 from 'globals';
+import pluginJsonc from 'eslint-plugin-jsonc';
+import jsoncParser from 'jsonc-eslint-parser';
+import pluginMarkdown from 'eslint-plugin-markdown';
+import pluginNext from '@next/eslint-plugin-next';
+import pluginProgress from '@aiou/eslint-plugin-progress';
+import pluginReact from 'eslint-plugin-react';
+import pluginReactHooks from 'eslint-plugin-react-hooks';
+import pluginReactRefresh from 'eslint-plugin-react-refresh';
+import pluginSSRFriendly from 'eslint-plugin-ssr-friendly';
+import pluginTailwindcss from 'eslint-plugin-tailwindcss';
+import pluginTypeScript from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+import pluginETC from 'eslint-plugin-etc';
+import pluginUnicorn from 'eslint-plugin-unicorn';
+import pluginYaml from 'eslint-plugin-yml';
+import yamlParser from 'yaml-eslint-parser';
+
+const comments = () => {
+  const config = [
+    {
+      plugins: {
+        "eslint-comments": pluginComments
+      },
+      rules: {
+        ...pluginComments.configs.recommended.rules,
+        "eslint-comments/disable-enable-pair": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const ignores = () => {
+  const config = [
+    {
+      ignores: ignoreGlobs
+    }
+  ];
+  return config;
+};
+
+const GLOB_SCRIPT_EXT = "?([cm])[jt]s?(x)";
+const GLOB_TEST_SCRIPT = "**/*.{spec,test}.?([cm])[jt]s?(x)";
+const GLOB_TEST_DIRS = "**/{test,tests,__test__,__tests__}/**";
+const GLOB_DTS = "**/*.d.ts";
+const GLOB_TS = "**/*.?([cm])ts";
+const GLOB_TSX = "**/*.?([cm])tsx";
+const GLOB_JSX = "**/*.?([cm])jsx";
+const GLOB_JSON = "**/*.json";
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_JSONC = "**/*.jsonc";
+const GLOB_MARKDOWN = "**/*.md";
+const GLOB_YAML = "**/*.y?(a)ml";
+const GLOB_WORKFLOW_YAML = "**/.github/**/*.y?(a)ml";
+
+const imports = () => {
+  const config = [
+    {
+      plugins: {
+        import: pluginImport,
+        "simple-import-sort": pluginSimpleImportSort,
+        "import-newlines": pluginImportNewlines,
+        "unused-imports": pluginUnsedImports
+      },
+      rules: {
+        ...pluginImport.configs.recommended.rules,
+        // import
+        // off: controlled by import/order
+        "import/order": "off",
+        "sort-imports": "off",
+        "simple-import-sort/imports": [
+          "warn",
+          {
+            groups: [
+              // Side effect imports.
+              ["^\\u0000"],
+              // Node.js builtins prefixed with `node:`.
+              ["^node:"],
+              // Packages.
+              // Things that start with a letter (or digit or underscore), or `@` followed by a letter.
+              ["^@?\\w"],
+              // Relative imports.
+              // Absolute imports and other imports such as `@/foo` or `~/foo`.
+              // Anything not matched in another group.
+              ["^", "^\\.", "^@/\\w", "^~/\\w"],
+              // Virtual modules prefixed with `virtual:`, rollup & vite favor
+              ["^virtual:"],
+              // Types
+              ["^[^/\\.].*\0$", "^\\..*\0$"]
+            ]
+          }
+        ],
+        "simple-import-sort/exports": "off",
+        "import/first": "error",
+        "import/newline-after-import": "error",
+        "import/no-duplicates": "error",
+        "import/no-mutable-exports": "error",
+        "import/no-unresolved": "off",
+        "import/no-absolute-path": "off",
+        "import/no-extraneous-dependencies": [
+          "error",
+          {
+            devDependencies: [
+              // ignore dev scripts
+              "**/scripts/**/*.{js,jsx,ts,tsx,cjs,mjs}",
+              "**/*.test.{js,jsx,ts,tsx,cjs,mjs}",
+              "**/*.spec.{js,jsx,ts,tsx,mjs,cjs}",
+              "**/*.config.{js,jsx,ts,tsx,cjs,mjs}",
+              // ignore require third packages in .eslintrc.* e.g. eslint-define-config
+              "**/.eslintrc.{js,cjs,mjs}"
+            ]
+          }
+        ],
+        // Not allow import { default as named }
+        "import/no-named-default": "warn",
+        "unused-imports/no-unused-imports": "error",
+        "unused-imports/no-unused-vars": [
+          "warn",
+          { vars: "all", varsIgnorePattern: "^_", args: "after-used", argsIgnorePattern: "^_" }
+        ],
+        // Enforce newlines inside named import
+        "import-newlines/enforce": [
+          "error",
+          {
+            items: 4,
+            "max-len": 120,
+            semi: false
+          }
+        ]
+      }
+    },
+    {
+      files: [GLOB_DTS],
+      rules: {
+        "import/no-duplicates": "off"
+      }
+    },
+    {
+      files: [GLOB_TSX, GLOB_JSX],
+      rules: {
+        // related: https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/docs/TROUBLESHOOTING.md#edits-always-lead-to-full-reload
+        // export anonymous function: ReactRefresh failed
+        "import/no-anonymous-default-export": "error",
+        // perfer named export
+        "import/no-default-export": "error"
+      }
+    },
+    {
+      files: [
+        `**/*config*.${GLOB_SCRIPT_EXT}`,
+        `**/pages/**/*.${GLOB_SCRIPT_EXT}`,
+        "**/{index,vite,esbuild,rollup,webpack,rspack}.ts",
+        GLOB_DTS
+      ],
+      rules: {
+        // related: https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/docs/TROUBLESHOOTING.md#edits-always-lead-to-full-reload
+        // export anonymous function: ReactRefresh failed
+        "import/no-anonymous-default-export": "off",
+        "import/no-default-export": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var eslintConfigStandardExports = {};
+var eslintConfigStandard = {
+  get exports(){ return eslintConfigStandardExports; },
+  set exports(v){ eslintConfigStandardExports = v; },
+};
+
+var parserOptions = {
+	ecmaVersion: 2022,
+	ecmaFeatures: {
+		jsx: true
+	},
+	sourceType: "module"
+};
+var env = {
+	es2021: true,
+	node: true
+};
+var plugins = [
+	"import",
+	"n",
+	"promise"
+];
+var globals = {
+	document: "readonly",
+	navigator: "readonly",
+	window: "readonly"
+};
+var rules = {
+	"no-var": "warn",
+	"object-shorthand": [
+		"warn",
+		"properties"
+	],
+	"accessor-pairs": [
+		"error",
+		{
+			setWithoutGet: true,
+			enforceForClassMembers: true
+		}
+	],
+	"array-bracket-spacing": [
+		"error",
+		"never"
+	],
+	"array-callback-return": [
+		"error",
+		{
+			allowImplicit: false,
+			checkForEach: false
+		}
+	],
+	"arrow-spacing": [
+		"error",
+		{
+			before: true,
+			after: true
+		}
+	],
+	"block-spacing": [
+		"error",
+		"always"
+	],
+	"brace-style": [
+		"error",
+		"1tbs",
+		{
+			allowSingleLine: true
+		}
+	],
+	camelcase: [
+		"error",
+		{
+			allow: [
+				"^UNSAFE_"
+			],
+			properties: "never",
+			ignoreGlobals: true
+		}
+	],
+	"comma-dangle": [
+		"error",
+		{
+			arrays: "never",
+			objects: "never",
+			imports: "never",
+			exports: "never",
+			functions: "never"
+		}
+	],
+	"comma-spacing": [
+		"error",
+		{
+			before: false,
+			after: true
+		}
+	],
+	"comma-style": [
+		"error",
+		"last"
+	],
+	"computed-property-spacing": [
+		"error",
+		"never",
+		{
+			enforceForClassMembers: true
+		}
+	],
+	"constructor-super": "error",
+	curly: [
+		"error",
+		"multi-line"
+	],
+	"default-case-last": "error",
+	"dot-location": [
+		"error",
+		"property"
+	],
+	"dot-notation": [
+		"error",
+		{
+			allowKeywords: true
+		}
+	],
+	"eol-last": "error",
+	eqeqeq: [
+		"error",
+		"always",
+		{
+			"null": "ignore"
+		}
+	],
+	"func-call-spacing": [
+		"error",
+		"never"
+	],
+	"generator-star-spacing": [
+		"error",
+		{
+			before: true,
+			after: true
+		}
+	],
+	indent: [
+		"error",
+		2,
+		{
+			SwitchCase: 1,
+			VariableDeclarator: 1,
+			outerIIFEBody: 1,
+			MemberExpression: 1,
+			FunctionDeclaration: {
+				parameters: 1,
+				body: 1
+			},
+			FunctionExpression: {
+				parameters: 1,
+				body: 1
+			},
+			CallExpression: {
+				"arguments": 1
+			},
+			ArrayExpression: 1,
+			ObjectExpression: 1,
+			ImportDeclaration: 1,
+			flatTernaryExpressions: false,
+			ignoreComments: false,
+			ignoredNodes: [
+				"TemplateLiteral *",
+				"JSXElement",
+				"JSXElement > *",
+				"JSXAttribute",
+				"JSXIdentifier",
+				"JSXNamespacedName",
+				"JSXMemberExpression",
+				"JSXSpreadAttribute",
+				"JSXExpressionContainer",
+				"JSXOpeningElement",
+				"JSXClosingElement",
+				"JSXFragment",
+				"JSXOpeningFragment",
+				"JSXClosingFragment",
+				"JSXText",
+				"JSXEmptyExpression",
+				"JSXSpreadChild"
+			],
+			offsetTernaryExpressions: true
+		}
+	],
+	"key-spacing": [
+		"error",
+		{
+			beforeColon: false,
+			afterColon: true
+		}
+	],
+	"keyword-spacing": [
+		"error",
+		{
+			before: true,
+			after: true
+		}
+	],
+	"lines-between-class-members": [
+		"error",
+		"always",
+		{
+			exceptAfterSingleLine: true
+		}
+	],
+	"multiline-ternary": [
+		"error",
+		"always-multiline"
+	],
+	"new-cap": [
+		"error",
+		{
+			newIsCap: true,
+			capIsNew: false,
+			properties: true
+		}
+	],
+	"new-parens": "error",
+	"no-array-constructor": "error",
+	"no-async-promise-executor": "error",
+	"no-caller": "error",
+	"no-case-declarations": "error",
+	"no-class-assign": "error",
+	"no-compare-neg-zero": "error",
+	"no-cond-assign": "error",
+	"no-const-assign": "error",
+	"no-constant-condition": [
+		"error",
+		{
+			checkLoops: false
+		}
+	],
+	"no-control-regex": "error",
+	"no-debugger": "error",
+	"no-delete-var": "error",
+	"no-dupe-args": "error",
+	"no-dupe-class-members": "error",
+	"no-dupe-keys": "error",
+	"no-duplicate-case": "error",
+	"no-useless-backreference": "error",
+	"no-empty": [
+		"error",
+		{
+			allowEmptyCatch: true
+		}
+	],
+	"no-empty-character-class": "error",
+	"no-empty-pattern": "error",
+	"no-eval": "error",
+	"no-ex-assign": "error",
+	"no-extend-native": "error",
+	"no-extra-bind": "error",
+	"no-extra-boolean-cast": "error",
+	"no-extra-parens": [
+		"error",
+		"functions"
+	],
+	"no-fallthrough": "error",
+	"no-floating-decimal": "error",
+	"no-func-assign": "error",
+	"no-global-assign": "error",
+	"no-implied-eval": "error",
+	"no-import-assign": "error",
+	"no-invalid-regexp": "error",
+	"no-irregular-whitespace": "error",
+	"no-iterator": "error",
+	"no-labels": [
+		"error",
+		{
+			allowLoop: false,
+			allowSwitch: false
+		}
+	],
+	"no-lone-blocks": "error",
+	"no-loss-of-precision": "error",
+	"no-misleading-character-class": "error",
+	"no-prototype-builtins": "error",
+	"no-useless-catch": "error",
+	"no-mixed-operators": [
+		"error",
+		{
+			groups: [
+				[
+					"==",
+					"!=",
+					"===",
+					"!==",
+					">",
+					">=",
+					"<",
+					"<="
+				],
+				[
+					"&&",
+					"||"
+				],
+				[
+					"in",
+					"instanceof"
+				]
+			],
+			allowSamePrecedence: true
+		}
+	],
+	"no-mixed-spaces-and-tabs": "error",
+	"no-multi-spaces": "error",
+	"no-multi-str": "error",
+	"no-multiple-empty-lines": [
+		"error",
+		{
+			max: 1,
+			maxBOF: 0,
+			maxEOF: 0
+		}
+	],
+	"no-new": "error",
+	"no-new-func": "error",
+	"no-new-object": "error",
+	"no-new-symbol": "error",
+	"no-new-wrappers": "error",
+	"no-obj-calls": "error",
+	"no-octal": "error",
+	"no-octal-escape": "error",
+	"no-proto": "error",
+	"no-redeclare": [
+		"error",
+		{
+			builtinGlobals: false
+		}
+	],
+	"no-regex-spaces": "error",
+	"no-return-assign": [
+		"error",
+		"except-parens"
+	],
+	"no-self-assign": [
+		"error",
+		{
+			props: true
+		}
+	],
+	"no-self-compare": "error",
+	"no-sequences": "error",
+	"no-shadow-restricted-names": "error",
+	"no-sparse-arrays": "error",
+	"no-tabs": "error",
+	"no-template-curly-in-string": "error",
+	"no-this-before-super": "error",
+	"no-throw-literal": "error",
+	"no-trailing-spaces": "error",
+	"no-undef": "error",
+	"no-undef-init": "error",
+	"no-unexpected-multiline": "error",
+	"no-unmodified-loop-condition": "error",
+	"no-unneeded-ternary": [
+		"error",
+		{
+			defaultAssignment: false
+		}
+	],
+	"no-unreachable": "error",
+	"no-unreachable-loop": "error",
+	"no-unsafe-finally": "error",
+	"no-unsafe-negation": "error",
+	"no-unused-expressions": [
+		"error",
+		{
+			allowShortCircuit: true,
+			allowTernary: true,
+			allowTaggedTemplates: true
+		}
+	],
+	"no-unused-vars": [
+		"error",
+		{
+			args: "none",
+			caughtErrors: "none",
+			ignoreRestSiblings: true,
+			vars: "all"
+		}
+	],
+	"no-use-before-define": [
+		"error",
+		{
+			functions: false,
+			classes: false,
+			variables: false
+		}
+	],
+	"no-useless-call": "error",
+	"no-useless-computed-key": "error",
+	"no-useless-constructor": "error",
+	"no-useless-escape": "error",
+	"no-useless-rename": "error",
+	"no-useless-return": "error",
+	"no-void": "error",
+	"no-whitespace-before-property": "error",
+	"no-with": "error",
+	"object-curly-newline": [
+		"error",
+		{
+			multiline: true,
+			consistent: true
+		}
+	],
+	"object-curly-spacing": [
+		"error",
+		"always"
+	],
+	"object-property-newline": [
+		"error",
+		{
+			allowMultiplePropertiesPerLine: true
+		}
+	],
+	"one-var": [
+		"error",
+		{
+			initialized: "never"
+		}
+	],
+	"operator-linebreak": [
+		"error",
+		"after",
+		{
+			overrides: {
+				"?": "before",
+				":": "before",
+				"|>": "before"
+			}
+		}
+	],
+	"padded-blocks": [
+		"error",
+		{
+			blocks: "never",
+			switches: "never",
+			classes: "never"
+		}
+	],
+	"prefer-const": [
+		"error",
+		{
+			destructuring: "all"
+		}
+	],
+	"prefer-promise-reject-errors": "error",
+	"prefer-regex-literals": [
+		"error",
+		{
+			disallowRedundantWrapping: true
+		}
+	],
+	"quote-props": [
+		"error",
+		"as-needed"
+	],
+	quotes: [
+		"error",
+		"single",
+		{
+			avoidEscape: true,
+			allowTemplateLiterals: false
+		}
+	],
+	"rest-spread-spacing": [
+		"error",
+		"never"
+	],
+	semi: [
+		"error",
+		"never"
+	],
+	"semi-spacing": [
+		"error",
+		{
+			before: false,
+			after: true
+		}
+	],
+	"space-before-blocks": [
+		"error",
+		"always"
+	],
+	"space-before-function-paren": [
+		"error",
+		"always"
+	],
+	"space-in-parens": [
+		"error",
+		"never"
+	],
+	"space-infix-ops": "error",
+	"space-unary-ops": [
+		"error",
+		{
+			words: true,
+			nonwords: false
+		}
+	],
+	"spaced-comment": [
+		"error",
+		"always",
+		{
+			line: {
+				markers: [
+					"*package",
+					"!",
+					"/",
+					",",
+					"="
+				]
+			},
+			block: {
+				balanced: true,
+				markers: [
+					"*package",
+					"!",
+					",",
+					":",
+					"::",
+					"flow-include"
+				],
+				exceptions: [
+					"*"
+				]
+			}
+		}
+	],
+	"symbol-description": "error",
+	"template-curly-spacing": [
+		"error",
+		"never"
+	],
+	"template-tag-spacing": [
+		"error",
+		"never"
+	],
+	"unicode-bom": [
+		"error",
+		"never"
+	],
+	"use-isnan": [
+		"error",
+		{
+			enforceForSwitchCase: true,
+			enforceForIndexOf: true
+		}
+	],
+	"valid-typeof": [
+		"error",
+		{
+			requireStringLiterals: true
+		}
+	],
+	"wrap-iife": [
+		"error",
+		"any",
+		{
+			functionPrototypeMethods: true
+		}
+	],
+	"yield-star-spacing": [
+		"error",
+		"both"
+	],
+	yoda: [
+		"error",
+		"never"
+	],
+	"import/export": "error",
+	"import/first": "error",
+	"import/no-absolute-path": [
+		"error",
+		{
+			esmodule: true,
+			commonjs: true,
+			amd: false
+		}
+	],
+	"import/no-duplicates": "error",
+	"import/no-named-default": "error",
+	"import/no-webpack-loader-syntax": "error",
+	"n/handle-callback-err": [
+		"error",
+		"^(err|error)$"
+	],
+	"n/no-callback-literal": "error",
+	"n/no-deprecated-api": "error",
+	"n/no-exports-assign": "error",
+	"n/no-new-require": "error",
+	"n/no-path-concat": "error",
+	"n/process-exit-as-throw": "error",
+	"promise/param-names": "error"
+};
+var require$$0 = {
+	parserOptions: parserOptions,
+	env: env,
+	plugins: plugins,
+	globals: globals,
+	rules: rules
+};
+
+/*! eslint-config-standard. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+(function (module) {
+	module.exports = require$$0;
+} (eslintConfigStandard));
+
+var pluginStandard = /*@__PURE__*/getDefaultExportFromCjs(eslintConfigStandardExports);
+
+const javascript = () => {
+  const config = [
+    {
+      languageOptions: {
+        globals: {
+          ...globals$1.browser,
+          ...globals$1.es2021,
+          ...globals$1.node
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          // Eslint doesn't supply ecmaVersion in `parser.js` `context.parserOptions`
+          // This is required to avoid ecmaVersion < 2015 error or 'import' / 'export' error
+          ecmaVersion: "latest",
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      settings: {
+        // This will do the trick
+        "import/parsers": {
+          espree: [".js", ".cjs", ".mjs", ".jsx"]
+        },
+        "import/resolver": {
+          node: true
+        }
+      },
+      plugins: {
+        n: pluginN,
+        promise: pluginPromise,
+        regexp: pluginRegexp
+      },
+      rules: {
+        ...pluginStandard.rules,
+        ...pluginRegexp.configs.recommended.rules,
+        // Common
+        semi: ["error", "never"],
+        // Always need {}
+        curly: ["error", "all"],
+        quotes: ["error", "single"],
+        "quote-props": ["error", "as-needed"],
+        "no-unused-vars": "warn",
+        "no-param-reassign": "off",
+        "array-bracket-spacing": ["error", "never"],
+        // https://eslint.org/docs/latest/rules/brace-style#1tbs
+        "brace-style": ["error", "1tbs"],
+        "block-spacing": ["error", "always"],
+        camelcase: "off",
+        "comma-spacing": ["error", { before: false, after: true }],
+        "comma-style": ["error", "last"],
+        "comma-dangle": ["error", "always-multiline"],
+        "no-constant-condition": "warn",
+        "no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
+        "no-console": process.env.NODE_ENV === "production" ? "error" : "off",
+        "no-cond-assign": ["error", "always"],
+        "func-call-spacing": ["off", "never"],
+        "key-spacing": ["error", { beforeColon: false, afterColon: true }],
+        // https://github.com/prettier/prettier-eslint/issues/226
+        indent: ["error", 2, { SwitchCase: 1, VariableDeclarator: 1, outerIIFEBody: 1 }],
+        "no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement"
+        ],
+        "object-curly-spacing": ["error", "always"],
+        "no-return-await": "off",
+        "space-before-function-paren": ["error", "never"],
+        // es6
+        "no-var": "error",
+        "prefer-const": [
+          "error",
+          {
+            destructuring: "any",
+            ignoreReadBeforeAssign: true
+          }
+        ],
+        "prefer-arrow-callback": [
+          "error",
+          {
+            allowNamedFunctions: false,
+            allowUnboundThis: true
+          }
+        ],
+        "object-shorthand": [
+          "error",
+          "always",
+          {
+            ignoreConstructors: false,
+            avoidQuotes: true
+          }
+        ],
+        "prefer-exponentiation-operator": "error",
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "template-curly-spacing": "error",
+        "arrow-parens": ["error", "as-needed", { requireForBlockBody: true }],
+        "generator-star-spacing": "off",
+        // best-practice
+        "array-callback-return": "error",
+        "block-scoped-var": "error",
+        "consistent-return": "off",
+        complexity: ["off", 11],
+        eqeqeq: ["error", "allow-null"],
+        "no-alert": "warn",
+        "no-case-declarations": "error",
+        "no-multi-spaces": "error",
+        "no-multi-str": "error",
+        "no-with": "error",
+        "no-void": "error",
+        "no-useless-escape": "off",
+        "vars-on-top": "error",
+        "require-await": "off",
+        "no-return-assign": "off",
+        "operator-linebreak": ["error", "before"]
+      }
+    }
+  ];
+  return config;
+};
+
+const jsonc = () => {
+  const config = [
+    {
+      files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+      languageOptions: {
+        parser: jsoncParser
+      },
+      plugins: {
+        jsonc: pluginJsonc
+      }
+    },
+    {
+      files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+      rules: {
+        ...pluginJsonc.configs["recommended-with-jsonc"].rules,
+        // refs: https://ota-meshi.github.io/eslint-plugin-jsonc/rules/indent.html
+        "jsonc/array-bracket-newline": [
+          "error",
+          {
+            multiline: true,
+            minItems: null
+          }
+        ],
+        "jsonc/array-bracket-spacing": ["error", "never"],
+        "jsonc/comma-dangle": ["error", "never"],
+        "jsonc/comma-style": ["error", "last"],
+        "jsonc/indent": ["error", 2, {}],
+        "jsonc/key-spacing": [
+          "error",
+          {
+            beforeColon: false,
+            afterColon: true,
+            mode: "strict"
+          }
+        ],
+        "jsonc/no-octal-escape": "error",
+        "jsonc/object-curly-newline": ["error", { multiline: true, consistent: true }],
+        "jsonc/object-curly-spacing": ["error", "always"]
+      }
+    },
+    {
+      files: ["**/package.json"],
+      rules: {
+        "jsonc/sort-keys": [
+          "error",
+          {
+            pathPattern: "^$",
+            order: [
+              "name",
+              "version",
+              "type",
+              "private",
+              "packageManager",
+              "description",
+              "keywords",
+              "license",
+              "engines",
+              "homepage",
+              "repository",
+              "bugs",
+              "funding",
+              "author",
+              "sideEffects",
+              "files",
+              "bin",
+              "exports",
+              "main",
+              "module",
+              "browser",
+              "typings",
+              "types",
+              "typeVersions",
+              "unpkg",
+              "scripts",
+              "husky",
+              "lint-staged",
+              "peerDependencies",
+              "peerDependenciesMeta",
+              "dependencies",
+              "optionalDependencies",
+              "devDependencies",
+              "pnpm",
+              "overrides",
+              "resolutions",
+              "eslintConfig",
+              "config"
+            ]
+          },
+          {
+            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$",
+            order: { type: "asc" }
+          },
+          {
+            pathPattern: "^exports.*$",
+            // According to webpack, default condition should be last item
+            order: ["import", "require", "types", "node", "browser", "default"]
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^resolutions$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^pnpm.overrides$"
+          }
+        ]
+      }
+    },
+    // refs: https://github.com/sxzz/eslint-config/blob/main/src/configs/sort.ts
+    {
+      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
+      rules: {
+        "jsonc/sort-keys": [
+          "error",
+          {
+            order: [
+              "extends",
+              "compilerOptions",
+              "references",
+              "files",
+              "include",
+              "exclude"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: [
+              /* Projects */
+              "incremental",
+              "composite",
+              "tsBuildInfoFile",
+              "disableSourceOfProjectReferenceRedirect",
+              "disableSolutionSearching",
+              "disableReferencedProjectLoad",
+              /* Language and Environment */
+              "target",
+              "jsx",
+              "jsxFactory",
+              "jsxFragmentFactory",
+              "jsxImportSource",
+              "lib",
+              "moduleDetection",
+              "noLib",
+              "reactNamespace",
+              "useDefineForClassFields",
+              "emitDecoratorMetadata",
+              "experimentalDecorators",
+              /* Modules */
+              "baseUrl",
+              "rootDir",
+              "rootDirs",
+              "customConditions",
+              "module",
+              "moduleResolution",
+              "moduleSuffixes",
+              "noResolve",
+              "paths",
+              "resolveJsonModule",
+              "resolvePackageJsonExports",
+              "resolvePackageJsonImports",
+              "typeRoots",
+              "types",
+              "allowArbitraryExtensions",
+              "allowImportingTsExtensions",
+              "allowUmdGlobalAccess",
+              /* JavaScript Support */
+              "allowJs",
+              "checkJs",
+              "maxNodeModuleJsDepth",
+              /* Type Checking */
+              "strict",
+              "strictBindCallApply",
+              "strictFunctionTypes",
+              "strictNullChecks",
+              "strictPropertyInitialization",
+              "allowUnreachableCode",
+              "allowUnusedLabels",
+              "alwaysStrict",
+              "exactOptionalPropertyTypes",
+              "noFallthroughCasesInSwitch",
+              "noImplicitAny",
+              "noImplicitOverride",
+              "noImplicitReturns",
+              "noImplicitThis",
+              "noPropertyAccessFromIndexSignature",
+              "noUncheckedIndexedAccess",
+              "noUnusedLocals",
+              "noUnusedParameters",
+              "useUnknownInCatchVariables",
+              /* Emit */
+              "declaration",
+              "declarationDir",
+              "declarationMap",
+              "downlevelIteration",
+              "emitBOM",
+              "emitDeclarationOnly",
+              "importHelpers",
+              "importsNotUsedAsValues",
+              "inlineSourceMap",
+              "inlineSources",
+              "mapRoot",
+              "newLine",
+              "noEmit",
+              "noEmitHelpers",
+              "noEmitOnError",
+              "outDir",
+              "outFile",
+              "preserveConstEnums",
+              "preserveValueImports",
+              "removeComments",
+              "sourceMap",
+              "sourceRoot",
+              "stripInternal",
+              /* Interop Constraints */
+              "allowSyntheticDefaultImports",
+              "esModuleInterop",
+              "forceConsistentCasingInFileNames",
+              "isolatedModules",
+              "preserveSymlinks",
+              "verbatimModuleSyntax",
+              /* Completeness */
+              "skipDefaultLibCheck",
+              "skipLibCheck"
+            ],
+            pathPattern: "^compilerOptions$"
+          }
+        ]
+      }
+    }
+  ];
+  return config;
+};
+
+const markdown = () => {
+  const config = [
+    {
+      // Enable the Markdown processor for all .md files.
+      files: [GLOB_MARKDOWN],
+      processor: "markdown/markdown",
+      plugins: {
+        markdown: pluginMarkdown
+      }
+    },
+    {
+      // Code blocks in markdown file
+      files: [`${GLOB_MARKDOWN}/*.${GLOB_SCRIPT_EXT}`],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            // Adding a "use strict" directive at the top of
+            // every code block is tedious and distracting, so
+            // opt into strict mode parsing without the
+            // directive.
+            impliedStrict: true
+          }
+        }
+      },
+      rules: {
+        ...pluginMarkdown.configs.recommended.overrides[1].rules,
+        "react/display-name": "off",
+        "@typescript-eslint/no-redeclare": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "@typescript-eslint/no-use-before-define": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/comma-dangle": "off",
+        "@typescript-eslint/consistent-type-imports": "off",
+        "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-require-imports": "off",
+        "import/no-unresolved": "off",
+        "unused-imports/no-unused-imports": "off",
+        "unused-imports/no-unused-vars": "off",
+        "no-alert": "off",
+        "no-console": "off",
+        "no-restricted-imports": "off",
+        "no-undef": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        // Off imports
+        "import/no-extraneous-dependencies": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const next = () => {
+  const config = [
+    {
+      files: [GLOB_JSX, GLOB_TSX],
+      plugins: {
+        "@next/next": pluginNext
+      },
+      rules: {
+        // Enable rules for next project
+        ...pluginNext.configs.recommended.rules
+      }
+    }
+  ];
+  return config;
+};
+
+const progress = () => {
+  const config = [
+    {
+      plugins: {
+        progress: pluginProgress
+      },
+      rules: {
+        "progress/activate": 1
+      }
+    }
+  ];
+  return config;
+};
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+/** Used for built-in method references. */
+var objectProto$b = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$b.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$8.call(value, symToStringTag$1),
+      tag = value[symToStringTag$1];
+
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+
+/** Used for built-in method references. */
+var objectProto$a = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$a.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return value != null && typeof value == 'object';
+}
+
+/** `Object#toString` result references. */
+var symbolTag$1 = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && baseGetTag(value) == symbolTag$1);
+}
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+/** Used as references for various `Number` constants. */
+var INFINITY$1 = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto$1 = Symbol ? Symbol.prototype : undefined,
+    symbolToString = symbolProto$1 ? symbolProto$1.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+  return value;
+}
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+    funcTag$1 = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/** Used for built-in method references. */
+var funcProto$1 = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString$1 = funcProto$1.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {}
+    try {
+      return (func + '');
+    } catch (e) {}
+  }
+  return '';
+}
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto$9 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty$7).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+var defineProperty = (function() {
+  try {
+    var func = getNative(Object, 'defineProperty');
+    func({}, '', {});
+    return func;
+  } catch (e) {}
+}());
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+
+  return !!length &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+  return typeof value == 'number' &&
+    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+
+/** Used for built-in method references. */
+var objectProto$8 = Object.prototype;
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+  var Ctor = value && value.constructor,
+      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$8;
+
+  return value === proto;
+}
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+  var index = -1,
+      result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+
+/** `Object#toString` result references. */
+var argsTag$2 = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+
+/** Used for built-in method references. */
+var objectProto$7 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable$1 = objectProto$7.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$6.call(value, 'callee') &&
+    !propertyIsEnumerable$1.call(value, 'callee');
+};
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+/** Detect free variable `exports`. */
+var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+
+/** Built-in value references. */
+var Buffer = moduleExports$1 ? root.Buffer : undefined;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+/** `Object#toString` result references. */
+var argsTag$1 = '[object Arguments]',
+    arrayTag$1 = '[object Array]',
+    boolTag$1 = '[object Boolean]',
+    dateTag$1 = '[object Date]',
+    errorTag$1 = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag$2 = '[object Map]',
+    numberTag$1 = '[object Number]',
+    objectTag$2 = '[object Object]',
+    regexpTag$1 = '[object RegExp]',
+    setTag$2 = '[object Set]',
+    stringTag$1 = '[object String]',
+    weakMapTag$1 = '[object WeakMap]';
+
+var arrayBufferTag$1 = '[object ArrayBuffer]',
+    dataViewTag$2 = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] =
+typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] =
+typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] =
+typedArrayTags[errorTag$1] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] =
+typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] =
+typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] =
+typedArrayTags[weakMapTag$1] = false;
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+  return isObjectLike(value) &&
+    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+  try {
+    // Use `util.types` for Node.js 10+.
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+    if (types) {
+      return types;
+    }
+
+    // Legacy `process.binding('util')` for Node.js < 10.
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+  } catch (e) {}
+}());
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+/** Used for built-in method references. */
+var objectProto$6 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$5.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+/** Used for built-in method references. */
+var objectProto$5 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$4.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+    reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+      value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+    (object != null && value in Object(object));
+}
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate = getNative(Object, 'create');
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto$4 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? undefined : result;
+  }
+  return hasOwnProperty$3.call(data, key) ? data[key] : undefined;
+}
+
+/** Used for built-in method references. */
+var objectProto$3 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$2.call(data, key);
+}
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash,
+    'map': new (Map || ListCache),
+    'string': new Hash
+  };
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+    : data.map;
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key),
+      size = data.size;
+
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache);
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize.Cache = MapCache;
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+
+  var cache = result.cache;
+  return result;
+}
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+  });
+  return result;
+});
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = castPath(path, object);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return (index && index == length) ? object : undefined;
+}
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+  this.__data__ = new ListCache;
+  this.size = 0;
+}
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+  var data = this.__data__,
+      result = data['delete'](key);
+
+  this.size = data.size;
+  return result;
+}
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+  return [];
+}
+
+/** Used for built-in method references. */
+var objectProto$2 = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+/* Built-in method references that are verified to be native. */
+var Promise$1 = getNative(root, 'Promise');
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+/** `Object#toString` result references. */
+var mapTag$1 = '[object Map]',
+    objectTag$1 = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag$1 = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag$1 = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map),
+    promiseCtorString = toSource(Promise$1),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$1) ||
+    (Map && getTag(new Map) != mapTag$1) ||
+    (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
+    (Set && getTag(new Set) != setTag$1) ||
+    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+  getTag = function(value) {
+    var result = baseGetTag(value),
+        Ctor = result == objectTag$1 ? value.constructor : undefined,
+        ctorString = Ctor ? toSource(Ctor) : '';
+
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString: return dataViewTag$1;
+        case mapCtorString: return mapTag$1;
+        case promiseCtorString: return promiseTag;
+        case setCtorString: return setTag$1;
+        case weakMapCtorString: return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+var getTag$1 = getTag;
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$5 = 1,
+    COMPARE_UNORDERED_FLAG$3 = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  // Check that cyclic values are equal.
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1,
+      result = true,
+      seen = (bitmask & COMPARE_UNORDERED_FLAG$3) ? new SetCache : undefined;
+
+  stack.set(array, other);
+  stack.set(other, array);
+
+  // Ignore non-index properties.
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, arrValue, index, other, array, stack)
+        : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    // Recursively compare arrays (susceptible to call stack limits).
+    if (seen) {
+      if (!arraySome(other, function(othValue, othIndex) {
+            if (!cacheHas(seen, othIndex) &&
+                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+        result = false;
+        break;
+      }
+    } else if (!(
+          arrValue === othValue ||
+            equalFunc(arrValue, othValue, bitmask, customizer, stack)
+        )) {
+      result = false;
+      break;
+    }
+  }
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+  var index = -1,
+      result = Array(map.size);
+
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+  var index = -1,
+      result = Array(set.size);
+
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$4 = 1,
+    COMPARE_UNORDERED_FLAG$2 = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if ((object.byteLength != other.byteLength) ||
+          (object.byteOffset != other.byteOffset)) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if ((object.byteLength != other.byteLength) ||
+          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == (other + '');
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+
+      // Recursively compare objects (susceptible to call stack limits).
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$3 = 1;
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  // Check that cyclic values are equal.
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, objValue, key, other, object, stack)
+        : customizer(objValue, othValue, key, object, other, stack);
+    }
+    // Recursively compare objects (susceptible to call stack limits).
+    if (!(compared === undefined
+          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+          : compared
+        )) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor &&
+        ('constructor' in object && 'constructor' in other) &&
+        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$2 = 1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = objIsArr ? arrayTag : getTag$1(object),
+      othTag = othIsArr ? arrayTag : getTag$1(other);
+
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+
+      stack || (stack = new Stack);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack);
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Unordered comparison
+ *  2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$1 = 1,
+    COMPARE_UNORDERED_FLAG$1 = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length,
+      length = index,
+      noCustomizer = !customizer;
+
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if ((noCustomizer && data[2])
+          ? data[1] !== object[data[0]]
+          : !(data[0] in object)
+        ) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0],
+        objValue = object[key],
+        srcValue = data[1];
+
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined
+            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack)
+            : result
+          )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ *  equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+  var result = keys(object),
+      length = result.length;
+
+  while (length--) {
+    var key = result[length],
+        value = object[key];
+
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue &&
+      (srcValue !== undefined || (key in Object(object)));
+  };
+}
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+
+  var index = -1,
+      length = path.length,
+      result = false;
+
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) &&
+    (isArray(object) || isArguments(object));
+}
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return (objValue === undefined && objValue === srcValue)
+      ? hasIn(object, path)
+      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': 2 } },
+ *   { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+  if (typeof value == 'function') {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == 'object') {
+    return isArray(value)
+      ? baseMatchesProperty(value[0], value[1])
+      : baseMatches(value);
+  }
+  return property(value);
+}
+
+/**
+ * Creates a base function for methods like `_.forIn` and `_.forOwn`.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1,
+        iterable = Object(object),
+        props = keysFunc(object),
+        length = props.length;
+
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+/**
+ * Creates an object with the same keys as `object` and values generated
+ * by running each own enumerable string keyed property of `object` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns the new mapped object.
+ * @see _.mapKeys
+ * @example
+ *
+ * var users = {
+ *   'fred':    { 'user': 'fred',    'age': 40 },
+ *   'pebbles': { 'user': 'pebbles', 'age': 1 }
+ * };
+ *
+ * _.mapValues(users, function(o) { return o.age; });
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.mapValues(users, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ */
+function mapValues(object, iteratee) {
+  var result = {};
+  iteratee = baseIteratee(iteratee);
+
+  baseForOwn(object, function(value, key, object) {
+    baseAssignValue(result, key, iteratee(value, key, object));
+  });
+  return result;
+}
+
+const react = () => {
+  const config = [
+    {
+      files: [GLOB_JSX, GLOB_TSX],
+      languageOptions: {
+        parserOptions: {
+          ...pluginReact.configs.recommended.parserOptions,
+          ...pluginReact.configs["jsx-runtime"].parserOptions
+        }
+      },
+      settings: {
+        react: {
+          // 'detect' will throw warn on monorepo
+          version: "18.0"
+        }
+      },
+      plugins: {
+        react: pluginReact,
+        "react-hooks": pluginReactHooks,
+        "ssr-friendly": pluginSSRFriendly,
+        "react-refresh": pluginReactRefresh
+      },
+      rules: {
+        ...pluginReact.configs.recommended.rules,
+        ...pluginReact.configs["jsx-runtime"].rules,
+        ...pluginReactHooks.configs.recommended.rules,
+        ...pluginSSRFriendly.configs.recommended.rules,
+        "jsx-quotes": ["error", "prefer-double"],
+        "react/prop-types": "off",
+        "react/no-unescaped-entities": "off",
+        "react/no-unknown-property": "off",
+        "react/jsx-boolean-value": ["error", "always"],
+        // Enforce new line when declare jsx element e.g. const element = (\newline<div
+        "react/jsx-wrap-multilines": [
+          "warn",
+          {
+            declaration: "parens-new-line",
+            assignment: "parens-new-line",
+            return: "parens-new-line",
+            arrow: "parens-new-line",
+            condition: "parens-new-line",
+            logical: "parens-new-line",
+            prop: "parens-new-line"
+          }
+        ],
+        "react/jsx-closing-tag-location": "error",
+        // Enforce disallow </ div>
+        "react/jsx-tag-spacing": ["error", { closingSlash: "never", beforeSelfClosing: "always", afterOpening: "never", beforeClosing: "allow" }],
+        "react/jsx-max-props-per-line": ["warn", { maximum: 1, when: "multiline" }],
+        // indentLogicalExpressions will fix && element
+        "react/jsx-indent": ["warn", 2, { indentLogicalExpressions: true }],
+        "react/jsx-indent-props": ["warn", 2],
+        // < and > should be on the same line(y-axis) if jsx is multiline
+        "react/jsx-closing-bracket-location": ["warn", "tag-aligned"],
+        // Enforce new line when multiline props jsx
+        "react/jsx-first-prop-new-line": ["warn", "multiline-multiprop"],
+        // https://github.com/ArnaudBarre/eslint-plugin-react-refresh
+        "react-refresh/only-export-components": "warn"
+      }
+    },
+    {
+      files: ["**/*.test.{js,jsx,ts,tsx,cjs,mjs}", "**/*.spec.{js,jsx,ts,tsx,mjs,cjs}"],
+      rules: {
+        ...mapValues(pluginSSRFriendly.configs.recommended.rules, () => "off"),
+        "ssr-friendly/only-export-components": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const tailwindcss = () => {
+  const config = [
+    {
+      plugins: {
+        tailwindcss: pluginTailwindcss
+      },
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      rules: {
+        ...pluginTailwindcss.configs.recommended.rules,
+        "tailwindcss/no-custom-classname": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const typescript = () => {
+  const config = [
+    {
+      files: [GLOB_TSX, GLOB_TS, GLOB_TEST_SCRIPT],
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          sourceType: "module"
+        }
+      },
+      settings: {
+        "import/resolver": {
+          node: { extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".d.ts"] }
+        }
+      },
+      plugins: {
+        "@typescript-eslint": pluginTypeScript,
+        etc: pluginETC
+      },
+      rules: {
+        ...pluginTypeScript.configs.recommended.rules,
+        // https://github.com/typescript-eslint/typescript-eslint/blob/main/docs/linting/troubleshooting/Performance.md#eslint-plugin-import
+        "import/named": "off",
+        "import/namespace": "off",
+        "import/default": "off",
+        "import/no-named-as-default-member": "off",
+        "import/no-named-as-default": "off",
+        // TS
+        "no-useless-constructor": "off",
+        indent: "off",
+        // https://github.com/prettier/prettier-eslint/issues/226
+        // JSX indent config in react
+        "@typescript-eslint/indent": ["error", 2, {
+          SwitchCase: 1,
+          VariableDeclarator: 1,
+          outerIIFEBody: 1,
+          MemberExpression: 1,
+          FunctionDeclaration: { parameters: 1, body: 1 },
+          FunctionExpression: { parameters: 1, body: 1 },
+          CallExpression: { arguments: 1 },
+          ArrayExpression: 1,
+          ObjectExpression: 1,
+          ImportDeclaration: 1,
+          flatTernaryExpressions: false,
+          ignoreComments: false,
+          ignoredNodes: [
+            "TemplateLiteral *",
+            "JSXElement",
+            "JSXElement > *",
+            "JSXAttribute",
+            "JSXIdentifier",
+            "JSXNamespacedName",
+            "JSXMemberExpression",
+            "JSXSpreadAttribute",
+            "JSXExpressionContainer",
+            "JSXOpeningElement",
+            "JSXClosingElement",
+            "JSXFragment",
+            "JSXOpeningFragment",
+            "JSXClosingFragment",
+            "JSXText",
+            "JSXEmptyExpression",
+            "JSXSpreadChild",
+            "TSTypeParameterInstantiation",
+            "FunctionExpression > .params[decorators.length > 0]",
+            "FunctionExpression > .params > :matches(Decorator, :not(:first-child))",
+            "ClassBody.body > PropertyDefinition[decorators.length > 0] > .key"
+          ],
+          offsetTernaryExpressions: true
+        }],
+        "@typescript-eslint/member-delimiter-style": ["error", { multiline: { delimiter: "none" } }],
+        "@typescript-eslint/type-annotation-spacing": ["error", {}],
+        "@typescript-eslint/ban-ts-comment": ["error", { "ts-ignore": "allow-with-description" }],
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          { prefer: "type-imports", disallowTypeAnnotations: false }
+        ],
+        // Limit `interface` define object types, users could override with *.d.ts declare
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        "@typescript-eslint/prefer-ts-expect-error": "warn",
+        "@typescript-eslint/default-param-last": "error",
+        // Perfer reduce<T, S>
+        "@typescript-eslint/prefer-reduce-type-parameter": "error",
+        // Sort type S = A | B
+        "@typescript-eslint/sort-type-constituents": "error",
+        "@typescript-eslint/unbound-method": "off",
+        "@typescript-eslint/prefer-for-of": "error",
+        // https://www.npmjs.com/package/eslint-plugin-etc
+        "etc/no-t": "error",
+        /**
+         * refs:
+         * 1. https://ncjamieson.com/dont-export-const-enums/
+         * 2. https://www.huy.rocks/everyday/02-24-2022-typescript-enums-at-runtime-and-tree-shaking
+         */
+        "etc/no-const-enum": "error",
+        "etc/no-enum": "error",
+        "etc/no-misused-generics": "error",
+        // Overrides JS
+        // no-spaced-func alert -- https://eslint.org/docs/latest/rules/no-spaced-func
+        "func-call-spacing": "off",
+        "@typescript-eslint/func-call-spacing": ["error", "never"],
+        "no-unused-vars": "off",
+        "no-redeclare": "off",
+        "@typescript-eslint/no-redeclare": "error",
+        "no-dupe-class-members": "off",
+        "@typescript-eslint/no-dupe-class-members": "error",
+        "no-use-before-define": "off",
+        "@typescript-eslint/no-use-before-define": [
+          "error",
+          { functions: false, classes: false, variables: true }
+        ],
+        "brace-style": "off",
+        // https://eslint.org/docs/latest/rules/brace-style#1tbs
+        "@typescript-eslint/brace-style": ["error", "1tbs"],
+        "comma-dangle": "off",
+        "@typescript-eslint/comma-dangle": ["error", "always-multiline"],
+        "object-curly-spacing": "off",
+        "@typescript-eslint/object-curly-spacing": ["error", "always"],
+        semi: "off",
+        "@typescript-eslint/semi": ["error", "never"],
+        quotes: "off",
+        "@typescript-eslint/quotes": ["error", "single"],
+        "space-before-blocks": "off",
+        "@typescript-eslint/space-before-blocks": ["error", "always"],
+        "space-before-function-paren": "off",
+        "@typescript-eslint/space-before-function-paren": [
+          "error",
+          {
+            anonymous: "always",
+            named: "never",
+            asyncArrow: "always"
+          }
+        ],
+        "space-infix-ops": "off",
+        "@typescript-eslint/space-infix-ops": "error",
+        "keyword-spacing": "off",
+        "@typescript-eslint/keyword-spacing": ["error", { before: true, after: true }],
+        "comma-spacing": "off",
+        "@typescript-eslint/comma-spacing": ["error", { before: false, after: true }],
+        "no-extra-parens": "off",
+        "@typescript-eslint/no-extra-parens": ["error", "functions"],
+        "no-loss-of-precision": "off",
+        "@typescript-eslint/no-loss-of-precision": "error",
+        "lines-between-class-members": "off",
+        "@typescript-eslint/lines-between-class-members": [
+          "error",
+          "always",
+          { exceptAfterSingleLine: true }
+        ],
+        // off
+        "@typescript-eslint/camelcase": "off",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-parameter-properties": "off",
+        "@typescript-eslint/no-empty-interface": "off",
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "@typescript-eslint/no-empty-function": "off",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/ban-types": "off",
+        "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        // https://www.npmjs.com/package/eslint-plugin-unused-imports
+        "@typescript-eslint/no-unused-vars": "off",
+        "no-void": ["error", { allowAsStatement: true }]
+      }
+    },
+    {
+      files: [GLOB_TEST_SCRIPT, GLOB_TEST_DIRS],
+      rules: {
+        "no-unused-expressions": "off",
+        "@typescript-eslint/no-unused-vars": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const unicorn = () => {
+  const config = [
+    {
+      plugins: {
+        unicorn: pluginUnicorn
+      },
+      rules: {
+        // unicorns
+        // Pass error message when throwing errors
+        "unicorn/error-message": "error",
+        // Uppercase regex escapes
+        "unicorn/escape-case": "error",
+        // Array.isArray instead of instanceof
+        "unicorn/no-array-instanceof": "error",
+        // Prevent deprecated `new Buffer()`
+        "unicorn/no-new-buffer": "error",
+        // Keep regex literals safe!
+        "unicorn/no-unsafe-regex": "off",
+        // Lowercase number formatting for octal, hex, binary (0x1'error' instead of 0X1'error')
+        "unicorn/number-literal-case": "error",
+        // ** instead of Math.pow()
+        "unicorn/prefer-exponentiation-operator": "error",
+        // includes over indexOf when checking for existence
+        "unicorn/prefer-includes": "error",
+        // String methods startsWith/endsWith instead of more complicated stuff
+        "unicorn/prefer-starts-ends-with": "error",
+        // textContent instead of innerText
+        "unicorn/prefer-text-content": "error",
+        // Enforce throwing type error when throwing error while checking typeof
+        "unicorn/prefer-type-error": "error",
+        // Use new when throwing error
+        "unicorn/throw-new-error": "error",
+        // Use `node:` for built-in node modules
+        "unicorn/prefer-node-protocol": "warn"
+      }
+    }
+  ];
+  return config;
+};
+
+const yml = () => {
+  const config = [
+    {
+      files: [GLOB_YAML],
+      languageOptions: {
+        parser: yamlParser
+      },
+      plugins: {
+        yml: pluginYaml
+      },
+      rules: {
+        ...pluginYaml.configs.standard.rules,
+        // yml
+        "spaced-comment": "off",
+        "yml/quotes": ["error", { prefer: "double", avoidEscape: false }],
+        "yml/no-empty-document": "off"
+      }
+    },
+    {
+      files: [GLOB_WORKFLOW_YAML],
+      rules: {
+        /**
+         * on:
+         *  push:
+         *  pull_request:
+         *   branches: []
+         */
+        "yml/no-empty-mapping-value": "off"
+      }
+    }
+  ];
+  return config;
+};
+
+const presetJavascript = [
+  ...ignores(),
+  ...javascript(),
+  ...comments(),
+  ...imports(),
+  ...unicorn()
+];
+const presetTypescript = [
+  ...presetJavascript,
+  ...typescript()
+];
+const presetLangsExtensions = [
+  ...yml(),
+  ...markdown(),
+  ...jsonc()
+];
+const presetDefault = [
+  ...presetTypescript,
+  ...react(),
+  ...presetLangsExtensions,
+  ...progress()
+];
+const aiou = (config = []) => {
+  const configs = [...presetDefault];
+  if (isPackageExists("tailwindcss")) {
+    configs.push(...tailwindcss());
+  }
+  if (isPackageExists("next")) {
+    configs.push(...next());
+  }
+  if (Object.keys(config).length > 0) {
+    configs.push(...Array.isArray(config) ? config : [config]);
+  }
+  return configs;
+};
+
+export { aiou };