@favorodera/eslint-config 0.0.0

package/README.md

@@ -0,0 +1 @@
+# Eslint Config

package/dist/index.cjs

@@ -0,0 +1,689 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let eslint_flat_config_utils = require("eslint-flat-config-utils");
+let defu = require("defu");
+let eslint_merge_processors = require("eslint-merge-processors");
+let globals = require("globals");
+globals = __toESM(globals, 1);
+//#region src/utils.ts
+/**
+* Return the default export from a module-like object.
+* If the module has no default export, return the original resolved value.
+*
+* @param module - module or promise resolving to a module
+* @returns resolved module default or original module
+*/
+async function getModuleDefault(module) {
+	const resolvedModule = await module;
+	return resolvedModule.default || resolvedModule;
+}
+/**
+* Normalize boolean or options value into merged options or null.
+* Returns null when the input is false or undefined.
+*
+* @param value - boolean, options object, or undefined
+* @param defaults - defaults to merge with
+* @returns merged options or false
+*/
+function resolveOptions(value, defaults) {
+	if (!value) return false;
+	return (0, defu.defu)(value === true ? {} : value, defaults);
+}
+/**
+* Rename rules by replacing configured plugin prefixes.
+*
+* @param rules - rules object to rename
+* @param map - prefix map used for renaming
+* @returns renamed rules object
+*/
+function renameRules(rules, map) {
+	return Object.fromEntries(Object.entries(rules).map(([key, value]) => {
+		for (const [from, to] of Object.entries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
+		return [key, value];
+	}));
+}
+//#endregion
+//#region src/globs.ts
+/** Glob pattern for JavaScript linting */
+const jsGlob = "**/*.?([cm])js";
+/** Glob pattern for TypeScript linting */
+const tsGlob = "**/*.?([cm])ts";
+/** Glob pattern for Vue linting */
+const vueGlob = "**/*.vue";
+/** Glob pattern for Markdown linting */
+const mdGlob = "**/*.md";
+/**
+* Default glob patterns for files and directories to ignore
+* Includes common build outputs, dependencies, caches, and temporary files
+*/
+const ignoresGlob = [
+	"**/node_modules",
+	"**/dist",
+	"**/package-lock.json",
+	"**/yarn.lock",
+	"**/pnpm-lock.yaml",
+	"**/bun.lockb",
+	"**/output",
+	"**/coverage",
+	"**/temp",
+	"**/.temp",
+	"**/tmp",
+	"**/.tmp",
+	"**/.history",
+	"**/.vitepress/cache",
+	"**/.nuxt",
+	"**/.next",
+	"**/.svelte-kit",
+	"**/.vercel",
+	"**/.changeset",
+	"**/.idea",
+	"**/.cache",
+	"**/.output",
+	"**/.vite-inspect",
+	"**/.yarn",
+	"**/CHANGELOG*.md",
+	"**/LICENSE*",
+	"**/*.min.*",
+	"**/__snapshots__",
+	"**/vite.config.*.timestamp-*",
+	"**/auto-import?(s).d.ts",
+	"**/components.d.ts",
+	"**/.context",
+	"**/.claude",
+	"**/.agents",
+	"**/.*/skills"
+];
+//#endregion
+//#region src/configs/vue.ts
+const sfcBlocksDefaults = { blocks: {
+	styles: true,
+	customBlocks: true,
+	template: false
+} };
+const vueDefaults = {
+	files: [vueGlob],
+	sfcBlocks: sfcBlocksDefaults
+};
+/**
+* Vue SFC linting via `vue-eslint-parser`, `eslint-plugin-vue`, `typescript-eslint(parser)`.
+* @param options - Vue configuration options
+* @returns Promise resolving to Vue ESLint config items
+*/
+async function vue(options) {
+	const resolved = (0, defu.defu)(options, vueDefaults);
+	const sfcBlocks = resolveOptions(resolved.sfcBlocks, sfcBlocksDefaults);
+	const [vuePlugin, vueParser, tsEsLint, vueBlocksProcessor] = await Promise.all([
+		getModuleDefault(import("eslint-plugin-vue")),
+		getModuleDefault(import("vue-eslint-parser")),
+		getModuleDefault(import("typescript-eslint")),
+		getModuleDefault(import("eslint-processor-vue-blocks"))
+	]);
+	return [{
+		name: "favorodera/vue/rules",
+		plugins: { vue: vuePlugin },
+		files: resolved.files,
+		languageOptions: {
+			globals: {
+				computed: "readonly",
+				defineEmits: "readonly",
+				defineExpose: "readonly",
+				defineProps: "readonly",
+				onMounted: "readonly",
+				onUnmounted: "readonly",
+				reactive: "readonly",
+				ref: "readonly",
+				shallowReactive: "readonly",
+				shallowRef: "readonly",
+				toRef: "readonly",
+				toRefs: "readonly",
+				watch: "readonly",
+				watchEffect: "readonly"
+			},
+			parser: vueParser,
+			parserOptions: {
+				parser: tsEsLint.parser,
+				extraFileExtensions: [".vue"],
+				sourceType: "module"
+			}
+		},
+		processor: sfcBlocks === false ? vuePlugin.processors[".vue"] : (0, eslint_merge_processors.mergeProcessors)([vuePlugin.processors[".vue"], vueBlocksProcessor(sfcBlocks)]),
+		rules: {
+			...vuePlugin.configs.base.rules,
+			...vuePlugin.configs["flat/essential"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
+				...accumulator,
+				...currentConfig
+			}), {}),
+			...vuePlugin.configs["flat/strongly-recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
+				...accumulator,
+				...currentConfig
+			}), {}),
+			...vuePlugin.configs["flat/recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
+				...accumulator,
+				...currentConfig
+			}), {}),
+			"vue/block-order": ["error", { order: [
+				"script",
+				"template",
+				"style"
+			] }],
+			"vue/component-name-in-template-casing": ["error", "PascalCase"],
+			"vue/component-options-name-casing": ["error", "PascalCase"],
+			"vue/multi-word-component-names": "off",
+			"vue/block-tag-newline": ["error", {
+				multiline: "ignore",
+				singleline: "ignore"
+			}],
+			"vue/multiline-html-element-content-newline": ["error", {
+				allowEmptyLines: true,
+				ignores: ["pre", "textarea"]
+			}],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/typescript.ts
+const typescriptDefaults = { files: [tsGlob] };
+/**
+* Extract and merge rules from a compatible config array.
+* @param configs - Array of compatible ESLint configs
+* @returns Merged rules object from all configs
+*/
+function extractRules(configs) {
+	return Object.assign({}, ...configs.map((config) => config.rules || {}));
+}
+/**
+* Typescript linting via `typescript-eslint`.
+* @param options - TypeScript configuration options
+* @returns Promise resolving to TypeScript ESLint config items
+*/
+async function typescript(options) {
+	const resolved = (0, defu.defu)(options, typescriptDefaults);
+	const tsEsLint = await getModuleDefault(import("typescript-eslint"));
+	return [{
+		name: "favorodera/typescript/rules",
+		files: resolved.files,
+		plugins: { ts: tsEsLint.plugin },
+		languageOptions: {
+			parser: tsEsLint.parser,
+			parserOptions: { sourceType: "module" }
+		},
+		rules: {
+			...renameRules(extractRules(tsEsLint.configs.strict), { "@typescript-eslint": "ts" }),
+			...renameRules(extractRules(tsEsLint.configs.stylistic), { "@typescript-eslint": "ts" }),
+			"ts/consistent-type-imports": ["error", { prefer: "type-imports" }],
+			"ts/no-empty-object-type": ["error", { allowInterfaces: "with-single-extends" }],
+			"ts/array-type": ["error", { default: "array" }],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/ignores.ts
+const defaultPatterns = ignoresGlob;
+/**
+* Globs for ignoring files and directories from ESLint scanning.
+* @param patterns - Additional ignore patterns or a function to modify the defaults.
+* @returns An array containing the ignore flat config item.
+*/
+function ignores(patterns = []) {
+	return [{
+		name: "favorodera/ignores",
+		ignores: typeof patterns === "function" ? patterns(defaultPatterns) : [...defaultPatterns, ...patterns]
+	}];
+}
+//#endregion
+//#region src/configs/stylistic.ts
+const stylisticDefaults = {
+	indent: 2,
+	experimental: false,
+	quotes: "single",
+	semi: false,
+	jsx: false
+};
+/**
+* Code style via `@stylistic/eslint-plugin`.
+* @param options - Stylistic configuration options
+* @returns Promise resolving to stylistic ESLint config items
+*/
+async function stylistic(options) {
+	const resolved = (0, defu.defu)(options, stylisticDefaults);
+	const stylePlugin = await getModuleDefault(import("@stylistic/eslint-plugin"));
+	const customizedStyleConfig = stylePlugin.configs.customize({
+		pluginName: "style",
+		...resolved
+	});
+	return [{
+		name: "favorodera/stylistic/rules",
+		plugins: { style: stylePlugin },
+		rules: {
+			...customizedStyleConfig.rules,
+			"style/quotes": [
+				"error",
+				"single",
+				{ avoidEscape: true }
+			],
+			"style/no-multiple-empty-lines": ["error", {
+				max: 2,
+				maxEOF: 2,
+				maxBOF: 0
+			}],
+			"style/padded-blocks": "off",
+			"style/no-trailing-spaces": ["error", { skipBlankLines: true }],
+			"style/brace-style": "off",
+			"style/generator-star-spacing": ["error", {
+				after: true,
+				before: false
+			}],
+			"style/yield-star-spacing": ["error", {
+				after: true,
+				before: false
+			}],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/tailwind.ts
+const tailwindDefaults = {
+	files: [
+		jsGlob,
+		tsGlob,
+		vueGlob
+	],
+	settings: { detectComponentClasses: true }
+};
+/**
+* Tailwind linting via `eslint-plugin-better-tailwindcss`.
+* @param options - Tailwind configuration options
+* @returns Promise resolving to Tailwind ESLint config items
+*/
+async function tailwind(options) {
+	const resolved = (0, defu.defu)(options, tailwindDefaults);
+	const tailwindPlugin = await getModuleDefault(import("eslint-plugin-better-tailwindcss"));
+	return [{
+		name: "favorodera/tailwind/rules",
+		plugins: { tailwind: tailwindPlugin },
+		files: resolved.files,
+		settings: { tailwindcss: resolved.settings },
+		rules: {
+			...renameRules(tailwindPlugin.configs["recommended-error"].rules, { "better-tailwindcss": "tailwind" }),
+			...renameRules(tailwindPlugin.configs["stylistic-error"].rules, { "better-tailwindcss": "tailwind" }),
+			"tailwind/no-unregistered-classes": "off",
+			"tailwind/enforce-consistent-line-wrapping": ["error", { group: "emptyLine" }],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/comments.ts
+const commentsDefaults = { files: [
+	jsGlob,
+	tsGlob,
+	vueGlob
+] };
+/**
+* Comments linting via `@eslint-community/eslint-plugin-eslint-comments`
+* @param options - Comments configuration options
+* @returns Promise resolving to comments ESLint config items
+*/
+async function comments(options) {
+	const resolved = (0, defu.defu)(options, commentsDefaults);
+	const commentsPlugin = await getModuleDefault(import("@eslint-community/eslint-plugin-eslint-comments"));
+	return [{
+		name: "favorodera/comments/rules",
+		files: resolved.files,
+		plugins: { comments: commentsPlugin },
+		rules: {
+			...renameRules(commentsPlugin.configs.recommended?.rules || {}, { "@eslint-community/eslint-comments": "comments" }),
+			"comments/no-aggregating-enable": "error",
+			"comments/no-duplicate-disable": "error",
+			"comments/no-unlimited-disable": "error",
+			"comments/no-unused-enable": "error",
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/imports.ts
+const importsDefaults = { files: [
+	jsGlob,
+	tsGlob,
+	vueGlob
+] };
+/**
+* Imports & unused imports linting via `eslint-plugin-import-lite` and `eslint-plugin-unused-imports`.
+* @param options - Imports & unused imports configuration options
+* @returns Promise resolving to imports & unused imports ESLint config items
+*/
+async function imports(options) {
+	const resolved = (0, defu.defu)(options, importsDefaults);
+	const [importPlugin, unusedImportsPlugin] = await Promise.all([getModuleDefault(import("eslint-plugin-import-lite")), getModuleDefault(import("eslint-plugin-unused-imports"))]);
+	return [{
+		name: "favorodera/imports/rules",
+		files: resolved.files,
+		plugins: {
+			"import": importPlugin,
+			"unused-imports": unusedImportsPlugin
+		},
+		rules: {
+			...renameRules(importPlugin.configs.recommended?.rules || {}, { "import-lite": "import" }),
+			"import/consistent-type-specifier-style": ["error", "top-level"],
+			"import/first": "error",
+			"import/no-duplicates": "error",
+			"import/no-mutable-exports": "error",
+			"import/no-named-default": "error",
+			"import/newline-after-import": ["error", { count: 1 }],
+			"unused-imports/no-unused-imports": "error",
+			"unused-imports/no-unused-vars": ["error", {
+				args: "after-used",
+				argsIgnorePattern: "^_",
+				ignoreRestSiblings: true,
+				vars: "all",
+				varsIgnorePattern: "^_"
+			}],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/markdown.ts
+const markdownDefaults = {
+	files: [mdGlob],
+	gfm: true
+};
+/**
+* Markdown linting via `@eslint/markdown`.
+* @param options - Markdown configuration options
+* @returns Promise resolving to Markdown ESLint config items
+*/
+async function markdown(options) {
+	const resolved = (0, defu.defu)(options, markdownDefaults);
+	const markdownPlugin = await getModuleDefault(import("@eslint/markdown"));
+	return [{
+		name: "favorodera/markdown/rules",
+		files: resolved.files,
+		plugins: { md: markdownPlugin },
+		processor: (0, eslint_merge_processors.mergeProcessors)([markdownPlugin.processors?.markdown, eslint_merge_processors.processorPassThrough]),
+		language: resolved.gfm ? "md/gfm" : "md/commonmark",
+		rules: {
+			...renameRules(markdownPlugin.configs.recommended[0]?.rules || {}, { markdown: "md" }),
+			"md/fenced-code-language": "off",
+			"md/no-missing-label-refs": "off",
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/javascript.ts
+const javascriptDefaults = { files: [
+	jsGlob,
+	tsGlob,
+	vueGlob
+] };
+/**
+* Javascript linting via `eslint`
+* @param options - Javascript configuration options
+* @returns Promise resolving to javascript ESLint config items
+*/
+async function javascript(options) {
+	const resolved = (0, defu.defu)(options, javascriptDefaults);
+	const jsPlugin = await getModuleDefault(import("@eslint/js"));
+	return [{
+		name: "favorodera/javascript/rules",
+		files: resolved.files,
+		languageOptions: {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			globals: {
+				...globals.default.browser,
+				...globals.default.es2021,
+				...globals.default.node,
+				document: "readonly",
+				navigator: "readonly",
+				window: "readonly"
+			}
+		},
+		linterOptions: { reportUnusedDisableDirectives: true },
+		plugins: { js: jsPlugin },
+		rules: {
+			...jsPlugin.configs.recommended.rules,
+			"accessor-pairs": ["error", {
+				enforceForClassMembers: true,
+				setWithoutGet: true
+			}],
+			"array-callback-return": "error",
+			"block-scoped-var": "error",
+			"constructor-super": "error",
+			"default-case-last": "error",
+			"dot-notation": ["error", { allowKeywords: true }],
+			"eqeqeq": ["error", "smart"],
+			"new-cap": ["error", {
+				capIsNew: false,
+				newIsCap: true,
+				properties: true
+			}],
+			"no-alert": "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", "always"],
+			"no-console": ["error", { allow: ["warn", "error"] }],
+			"no-const-assign": "error",
+			"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-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-fallthrough": "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-multi-str": "error",
+			"no-new": "error",
+			"no-new-func": "error",
+			"no-new-native-nonconstructor": "error",
+			"no-new-wrappers": "error",
+			"no-obj-calls": "error",
+			"no-octal": "error",
+			"no-octal-escape": "error",
+			"no-proto": "error",
+			"no-prototype-builtins": "error",
+			"no-redeclare": ["error", { builtinGlobals: false }],
+			"no-regex-spaces": "error",
+			"no-restricted-globals": [
+				"error",
+				{
+					message: "Use `globalThis` instead.",
+					name: "global"
+				},
+				{
+					message: "Use `globalThis` instead.",
+					name: "self"
+				}
+			],
+			"no-restricted-properties": [
+				"error",
+				{
+					message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+					property: "__proto__"
+				},
+				{
+					message: "Use `Object.defineProperty` instead.",
+					property: "__defineGetter__"
+				},
+				{
+					message: "Use `Object.defineProperty` instead.",
+					property: "__defineSetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupGetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupSetter__"
+				}
+			],
+			"no-restricted-syntax": [
+				"error",
+				"TSEnumDeclaration[const=true]",
+				"TSExportAssignment"
+			],
+			"no-self-assign": ["error", { props: true }],
+			"no-self-compare": "error",
+			"no-sequences": "error",
+			"no-shadow-restricted-names": "error",
+			"no-sparse-arrays": "error",
+			"no-template-curly-in-string": "error",
+			"no-this-before-super": "error",
+			"no-throw-literal": "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,
+				allowTaggedTemplates: true,
+				allowTernary: true
+			}],
+			"no-unused-vars": ["error", {
+				args: "none",
+				caughtErrors: "none",
+				ignoreRestSiblings: true,
+				vars: "all"
+			}],
+			"no-use-before-define": ["error", {
+				classes: false,
+				functions: false,
+				variables: true
+			}],
+			"no-useless-backreference": "error",
+			"no-useless-call": "error",
+			"no-useless-catch": "error",
+			"no-useless-computed-key": "error",
+			"no-useless-constructor": "error",
+			"no-useless-rename": "error",
+			"no-useless-return": "error",
+			"no-var": "error",
+			"no-with": "error",
+			"object-shorthand": [
+				"error",
+				"always",
+				{
+					avoidQuotes: true,
+					ignoreConstructors: false
+				}
+			],
+			"one-var": ["error", { initialized: "never" }],
+			"prefer-arrow-callback": ["error", {
+				allowNamedFunctions: false,
+				allowUnboundThis: true
+			}],
+			"prefer-const": ["error", {
+				destructuring: "all",
+				ignoreReadBeforeAssign: true
+			}],
+			"prefer-exponentiation-operator": "error",
+			"prefer-promise-reject-errors": "error",
+			"prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+			"prefer-rest-params": "error",
+			"prefer-spread": "error",
+			"prefer-template": "error",
+			"symbol-description": "error",
+			"unicode-bom": ["error", "never"],
+			"use-isnan": ["error", {
+				enforceForIndexOf: true,
+				enforceForSwitchCase: true
+			}],
+			"valid-typeof": ["error", { requireStringLiterals: true }],
+			"vars-on-top": "error",
+			"yoda": ["error", "never"],
+			...resolved.overrides
+		}
+	}];
+}
+//#endregion
+//#region src/factory.ts
+/**
+* Factory to create a flat ESLint config
+* @param options - Configuration options for the ESLint config
+* @returns Flat ESLint config composer
+*/
+function factory(options = {}) {
+	const configs = [];
+	configs.push(ignores(options.ignores));
+	const vueOptions = resolveOptions(options.vue, {});
+	const typescriptOptions = resolveOptions(options.typescript, {});
+	const stylisticOptions = resolveOptions(options.stylistic, {});
+	const tailwindOptions = resolveOptions(options.tailwind, {});
+	const commentsOptions = resolveOptions(options.comments, {});
+	const importsOptions = resolveOptions(options.imports, {});
+	const markdownOptions = resolveOptions(options.markdown, {});
+	const javascriptOptions = resolveOptions(options.javascript, {});
+	if (vueOptions) configs.push(vue(vueOptions));
+	if (typescriptOptions) configs.push(typescript(typescriptOptions));
+	if (stylisticOptions) configs.push(stylistic(stylisticOptions));
+	if (tailwindOptions) configs.push(tailwind(tailwindOptions));
+	if (commentsOptions) configs.push(comments(commentsOptions));
+	if (importsOptions) configs.push(imports(importsOptions));
+	if (markdownOptions) configs.push(markdown(markdownOptions));
+	if (javascriptOptions) configs.push(javascript(javascriptOptions));
+	let composer = new eslint_flat_config_utils.FlatConfigComposer();
+	composer = composer.append(...configs);
+	return composer;
+}
+//#endregion
+exports.factory = factory;
+exports.getModuleDefault = getModuleDefault;
+exports.renameRules = renameRules;