@eslinted/core 5.0.0-rc.2 → 5.0.0-rc.4

package/dist/factory/options/index.d.ts

@@ -7,7 +7,6 @@ import html from "./html.js";
 import json from "./json.js";
 import jsonc from "./jsonc.js";
 import yml from "./yml.js";
-import md from "./md.js";
 declare const _default: {
     readonly js: typeof js;
     readonly ts: typeof ts;
@@ -17,7 +16,6 @@ declare const _default: {
     readonly json: typeof json;
     readonly jsonc: typeof jsonc;
     readonly yml: typeof yml;
-    readonly md: typeof md;
 };
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/factory/options/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/factory/options/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAE/C,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;AAEtB,wBAUW"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/factory/options/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAE/C,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,GAAG,MAAM,OAAO,CAAC;;;;;;;;;;;AAExB,wBASW"}

package/dist/factory/options/index.js

@@ -6,7 +6,6 @@ import html from "./html.js";
 import json from "./json.js";
 import jsonc from "./jsonc.js";
 import yml from "./yml.js";
-import md from "./md.js";
 export default {
     js,
     ts,
@@ -16,6 +15,5 @@ export default {
     json,
     jsonc,
     yml,
-    md,
 };
 //# sourceMappingURL=index.js.map

package/dist/factory/options/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/factory/options/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,EAAE,MAAM,MAAM,CAAC;AAEtB,eAAe;IACb,EAAE;IACF,EAAE;IACF,MAAM;IACN,KAAK;IACL,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,GAAG;IACH,EAAE;CACM,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/factory/options/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,EAAE,MAAM,MAAM,CAAC;AACtB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,GAAG,MAAM,OAAO,CAAC;AAExB,eAAe;IACb,EAAE;IACF,EAAE;IACF,MAAM;IACN,KAAK;IACL,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,GAAG;CACK,CAAC"}

package/dist/factory/options/option/index.d.ts

@@ -2,13 +2,13 @@ import type { Ruleset } from "../../rulesets/ruleset.js";
 import type { Scope, Input, Output, LanguageOptions, Plugins, Globals } from "./template/index.js";
 export default abstract class Option<S extends Scope, Plugin extends keyof Input["plugins"], IsEcma extends boolean = true, ParserOptions extends object | boolean = false, ParserCount extends 0 | 1 | 2 = 0, Global extends Globals = never, Processor extends object = never> {
     readonly plugins: Plugins<Plugin>;
-    readonly parser: Tuple<unknown, ParserCount>;
+    readonly parser: Tuple<ParserCount, unknown>;
     readonly files: string[];
     readonly ruleset: Ruleset;
     private readonly linterOptions;
     abstract readonly scope: literalful<S>;
     abstract readonly processor: Interface<Processor> extends never ? object : Interface<Processor> extends Readonly<Record<"processor", string>> ? Interface<Processor> : object;
-    constructor(plugins: Plugins<Plugin>, parser: Tuple<unknown, ParserCount>, files: string[], ruleset: Ruleset);
+    constructor(plugins: Plugins<Plugin>, parser: Tuple<ParserCount, unknown>, files: string[], ruleset: Ruleset);
     get configs(): Output;
     private get option();
     protected abstract get languageOptions(): LanguageOptions<IsEcma, ParserOptions, Global>;

package/dist/factory/options/option/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/factory/options/option/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EACV,KAAK,EACL,KAAK,EACL,MAAM,EAEN,eAAe,EACf,OAAO,EACP,OAAO,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAM,CAClC,CAAC,SAAS,KAAK,EACf,MAAM,SAAS,MAAM,KAAK,CAAC,SAAS,CAAC,EACrC,MAAM,SAAS,OAAO,GAAG,IAAI,EAC7B,aAAa,SAAS,MAAM,GAAG,OAAO,GAAG,KAAK,EAC9C,WAAW,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EACjC,MAAM,SAAS,OAAO,GAAG,KAAK,EAC9B,SAAS,SAAS,MAAM,GAAG,KAAK;aAYd,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC;aACxB,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC;aACnC,KAAK,EAAE,MAAM,EAAE;aACf,OAAO,EAAE,OAAO;IAblC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6E;IAE3G,kBAAyB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9C,kBAAyB,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,SAAS,KAAK,GAClE,MAAM,GACN,SAAS,CAAC,SAAS,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,GAChE,SAAS,CAAC,SAAS,CAAC,GACpB,MAAM,CAAC;gBAGK,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,EACnC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,OAAO;IAGlC,IAAW,OAAO,IAAI,MAAM,CAqB3B;IAED,OAAO,KAAK,MAAM,GAuBjB;IAED,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;IAEzF,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/factory/options/option/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EACV,KAAK,EACL,KAAK,EACL,MAAM,EAEN,eAAe,EACf,OAAO,EACP,OAAO,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAM,CAClC,CAAC,SAAS,KAAK,EACf,MAAM,SAAS,MAAM,KAAK,CAAC,SAAS,CAAC,EACrC,MAAM,SAAS,OAAO,GAAG,IAAI,EAC7B,aAAa,SAAS,MAAM,GAAG,OAAO,GAAG,KAAK,EAC9C,WAAW,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EACjC,MAAM,SAAS,OAAO,GAAG,KAAK,EAC9B,SAAS,SAAS,MAAM,GAAG,KAAK;aAYd,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC;aACxB,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC;aACnC,KAAK,EAAE,MAAM,EAAE;aACf,OAAO,EAAE,OAAO;IAblC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6E;IAE3G,kBAAyB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9C,kBAAyB,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,SAAS,KAAK,GAClE,MAAM,GACN,SAAS,CAAC,SAAS,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,GAChE,SAAS,CAAC,SAAS,CAAC,GACpB,MAAM,CAAC;gBAGK,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,EACnC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,OAAO;IAGlC,IAAW,OAAO,IAAI,MAAM,CAqB3B;IAED,OAAO,KAAK,MAAM,GAuBjB;IAED,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;IAEzF,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B"}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAE9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAOlC,MAAM,CAAC,OAAO,WACZ,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,EACzB,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,EACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EACrB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GACpB,MAAM,CAyER;AAGD,kBAAU,IAAI,CAAC;IACb,KAAY,MAAM,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;IAC3C,UAAiB,KAAK,CAAC;QACrB,KAAY,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,KAAY,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,KAAY,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,UAAiB,KAAK,CAAC;YACrB,KAAY,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,KAAY,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;SAC1C;QACD,KAAY,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,UAAiB,KAAK,CAAC;YACrB,KAAY,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,KAAY,SAAS,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;SAC5C;KACF;IACD,KAAY,MAAM,GAAG,MAAM,EAAE,CAAC;CAC/B;AAED,YAAY,EAAE,IAAI,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAE9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAOlC,MAAM,CAAC,OAAO,WACZ,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,EACzB,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,EACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EACrB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GACpB,MAAM,CAkER;AAGD,kBAAU,IAAI,CAAC;IACb,KAAY,MAAM,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;IAC3C,UAAiB,KAAK,CAAC;QACrB,KAAY,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,KAAY,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,KAAY,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,UAAiB,KAAK,CAAC;YACrB,KAAY,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,KAAY,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;SAC1C;QACD,KAAY,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,UAAiB,KAAK,CAAC;YACrB,KAAY,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,KAAY,SAAS,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;SAC5C;KACF;IACD,KAAY,MAAM,GAAG,MAAM,EAAE,CAAC;CAC/B;AAED,YAAY,EAAE,IAAI,EAAE,CAAC"}

package/dist/index.js

@@ -19,8 +19,6 @@ export default function (plugins, parsers, files, rules) {
                 .jsonc({ jsonc: plugins.jsonc }, [parsers.jsonc], F.files("jsonc"), R.ruleset("jsonc")).configs,
             yml: new Options
                 .yml({ yml: plugins.yml }, [parsers.yml], F.files("yml"), R.ruleset("yml")).configs,
-            md: new Options
-                .md({ markdownlint: plugins.markdownlint }, [parsers.md], F.files("md"), R.ruleset("md")).configs,
         };
         return scopes.flatMap(scope => options[scope]);
     }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,KAAK,EACL,QAAQ,EACR,OAAO,GACR,MAAM,WAAW,CAAC;AAEnB,MAAM,CAAC,OAAO,WACZ,OAAyB,EACzB,OAAyB,EACzB,KAAqB,EACrB,KAAqB;IAErB,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,EAC1B,CAAC,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,EACvB,OAAO,GAAiF;YACtF,EAAE,EAAE,IAAI,OAAO;iBACZ,EAAE,CACD,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,EACvC,EAAE,EACF,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EACb,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAChB,CAAC,OAAO;YACX,EAAE,EAAE,IAAI,OAAO;iBACZ,EAAE,CACD,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,CAAC,EAAE,EAC5F,CAAC,OAAO,CAAC,EAAE,CAAC,EACZ,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EACb,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAChB,CAAC,OAAO;YACX,MAAM,EAAE,IAAI,OAAO;iBAChB,MAAM,CACL,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,EACpH,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,EAC5B,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,EACjB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CACpB,CAAC,OAAO;YACX,KAAK,EAAE,IAAI,OAAO;iBACf,KAAK,CACJ,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,EAClH,CAAC,OAAO,CAAC,EAAE,CAAC,EACZ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,EAChB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CACnB,CAAC,OAAO;YACX,IAAI,EAAE,IAAI,OAAO;iBACd,IAAI,CACH,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,EAAE,EAC3C,CAAC,OAAO,CAAC,IAAI,CAAC,EACd,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EACf,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAClB,CAAC,OAAO;YACX,IAAI,EAAE,IAAI,OAAO;iBACd,IAAI,CACH,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,EACxB,CAAC,OAAO,CAAC,KAAK,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EACf,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAClB,CAAC,OAAO;YACX,KAAK,EAAE,IAAI,OAAO;iBACf,KAAK,CACJ,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,EACxB,CAAC,OAAO,CAAC,KAAK,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,EAChB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CACnB,CAAC,OAAO;YACX,GAAG,EAAE,IAAI,OAAO;iBACb,GAAG,CACF,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,EACpB,CAAC,OAAO,CAAC,GAAG,CAAC,EACb,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EACd,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CACjB,CAAC,OAAO;YACX,EAAE,EAAE,IAAI,OAAO;iBACZ,EAAE,CACD,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,EACtC,CAAC,OAAO,CAAC,EAAE,CAAC,EACZ,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EACb,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAChB,CAAC,OAAO;SACZ,CAAC;QAEF,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,CAAC,EAAE,CAAC;QAAC,MAAM,IAAI,KAAK,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAAC,CAAC;AAC7D,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/input/imports/parsers.d.ts

@@ -1,3 +1,3 @@
 import type { Scope } from "../index.js";
-export type Parsers = Scope & ("ts" | "svelte" | "html" | "jsonc" | "yml" | "md");
+export type Parsers = Scope & ("ts" | "svelte" | "html" | "jsonc" | "yml");
 //# sourceMappingURL=parsers.d.ts.map

package/dist/input/imports/parsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsers.d.ts","sourceRoot":"","sources":["../../../src/input/imports/parsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG,KAAK,GACvB,CACE,IAAI,GACJ,QAAQ,GACR,MAAM,GACN,OAAO,GACP,KAAK,GACL,IAAI,CACT,CAAC"}
+{"version":3,"file":"parsers.d.ts","sourceRoot":"","sources":["../../../src/input/imports/parsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG,KAAK,GACvB,CACE,IAAI,GACJ,QAAQ,GACR,MAAM,GACN,OAAO,GACP,KAAK,CACV,CAAC"}

package/dist/input/imports/plugins.d.ts

@@ -1,2 +1,2 @@
-export type Plugins = ("@stylistic" | "@typescript-eslint" | "svelte" | "mocha" | "@html-eslint" | "jsonc" | "yml" | "markdownlint");
+export type Plugins = ("@stylistic" | "@typescript-eslint" | "svelte" | "mocha" | "@html-eslint" | "jsonc" | "yml");
 //# sourceMappingURL=plugins.d.ts.map

package/dist/input/imports/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../src/input/imports/plugins.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAClB,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,OAAO,GACP,cAAc,GACd,OAAO,GACP,KAAK,GACL,cAAc,CACjB,CAAC"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../src/input/imports/plugins.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAClB,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,OAAO,GACP,cAAc,GACd,OAAO,GACP,KAAK,CACR,CAAC"}

package/dist/output.d.ts

@@ -12,7 +12,7 @@ export type Output = ({
         ecmaVersion?: "latest";
         globals?: Table<true>;
         parser?: unknown;
-        parserOptions?: Record<string, unknown>;
+        parserOptions?: Table;
     };
     plugins: Table<Record<"configs", unknown>>;
     processor?: string;

package/dist/output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;AAE/B,MAAM,MAAM,MAAM,GAAG,CACnB;IACE,IAAI,EAAE,UAAU,MAAM,EAAE,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE;QACb,cAAc,EAAE,IAAI,CAAC;QACrB,6BAA6B,EAAE,OAAO,CAAC;KACxC,CAAC;IACF,eAAe,EAAE;QACf,UAAU,CAAC,EACP,QAAQ,GACR,QAAQ,CAAC;QACb,WAAW,CAAC,EAAE,QAAQ,CAAC;QACvB,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACtB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACzC,CAAC;IACF,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CACF,EAAE,CAAC"}
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;AAE/B,MAAM,MAAM,MAAM,GAAG,CACnB;IACE,IAAI,EAAE,UAAU,MAAM,EAAE,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE;QACb,cAAc,EAAE,IAAI,CAAC;QACrB,6BAA6B,EAAE,OAAO,CAAC;KACxC,CAAC;IACF,eAAe,EAAE;QACf,UAAU,CAAC,EACP,QAAQ,GACR,QAAQ,CAAC;QACb,WAAW,CAAC,EAAE,QAAQ,CAAC;QACvB,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACtB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,aAAa,CAAC,EAAE,KAAK,CAAC;KACvB,CAAC;IACF,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CACF,EAAE,CAAC"}

package/dist/scopes.d.ts

@@ -1,3 +1,3 @@
 export type Scope = typeof scopes[number];
-export declare const scopes: readonly ["js", "ts", "svelte", "mocha", "html", "json", "jsonc", "yml", "md"];
+export declare const scopes: readonly ["js", "ts", "svelte", "mocha", "html", "json", "jsonc", "yml"];
 //# sourceMappingURL=scopes.d.ts.map

package/dist/scopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAC1C,eAAO,MAAM,MAAM,gFAUT,CAAC"}
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAC1C,eAAO,MAAM,MAAM,0EAST,CAAC"}

package/dist/scopes.js

@@ -7,6 +7,5 @@ export const scopes = [
     "json",
     "jsonc",
     "yml",
-    "md",
 ];
 //# sourceMappingURL=scopes.js.map

package/dist/scopes.js.map

@@ -1 +1 @@
-{"version":3,"file":"scopes.js","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI;IACJ,IAAI;IACJ,QAAQ;IACR,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,KAAK;IACL,IAAI;CACI,CAAC"}
+{"version":3,"file":"scopes.js","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI;IACJ,IAAI;IACJ,QAAQ;IACR,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,KAAK;CACG,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "_schemaVersion": "20.18.0",
   "name": "@eslinted/core",
-  "version": "5.0.0-rc.2",
+  "version": "5.0.0-rc.4",
   "description": "Core ESLint flat config factory npm package `linted`.",
   "keywords": [],
   "repository": "github:jimmy-zhening-luo/linted-core",

package/src/factory/options/index.ts

@@ -8,7 +8,6 @@ import html from "./html";
 import json from "./json";
 import jsonc from "./jsonc";
 import yml from "./yml";
-import md from "./md";
 
 export default {
   js,
@@ -19,5 +18,4 @@ export default {
   json,
   jsonc,
   yml,
-  md,
 } as const;

package/src/factory/options/option/index.ts

@@ -30,7 +30,7 @@ export default abstract class Option<
 
   constructor(
     public readonly plugins: Plugins<Plugin>,
-    public readonly parser: Tuple<unknown, ParserCount>,
+    public readonly parser: Tuple<ParserCount, unknown>,
     public readonly files: string[],
     public readonly ruleset: Ruleset,
   ) {}

package/src/index.ts

@@ -78,13 +78,6 @@ export default function (
           F.files("yml"),
           R.ruleset("yml"),
         ).configs,
-      md: new Options
-        .md(
-          { markdownlint: plugins.markdownlint },
-          [parsers.md],
-          F.files("md"),
-          R.ruleset("md"),
-        ).configs,
     };
 
     return scopes.flatMap(scope => options[scope]);

package/src/input/imports/parsers.ts

@@ -7,5 +7,4 @@ export type Parsers = Scope
     | "html"
     | "jsonc"
     | "yml"
-    | "md"
 );

package/src/input/imports/plugins.ts

@@ -6,5 +6,4 @@ export type Plugins = (
   | "@html-eslint"
   | "jsonc"
   | "yml"
-  | "markdownlint"
 );

package/src/output.ts

@@ -16,7 +16,7 @@ export type Output = (
       ecmaVersion?: "latest";
       globals?: Table<true>;
       parser?: unknown;
-      parserOptions?: Record<string, unknown>; // TODO: Change to Table<unknown> after lib update
+      parserOptions?: Table;
     };
     plugins: Table<Record<"configs", unknown>>;
     processor?: string;

package/src/scopes.ts

@@ -8,5 +8,4 @@ export const scopes = [
   "json",
   "jsonc",
   "yml",
-  "md",
 ] as const;

package/typings/{typioca → common}/utility/interface/build/properties/property/index.d.ts

@@ -3,6 +3,6 @@ declare type Property<K extends string, OK extends string, V> = literalful<K> ex
   : Recordful<K, V>
     & (
     literalful<OK> extends never
-      ? object
+      ? Recordful<K, V>
       : Particord<OK, V>
   );

package/typings/common/utility/iterable/build/arrays/array/index.d.ts

@@ -0,0 +1,11 @@
+declare type ArrayN<N extends number = 0, I = string> = [I] extends [never]
+  ? never
+  : N extends number
+    ? N extends 0 /* TODO: constrain posint */
+      ? [...I[]]
+      : ArrayBuilder<N, I>
+    : never;
+
+type ArrayBuilder<N extends number, I, H extends I[] = []> = H["length"] extends N
+  ? [...H, ...I[]]
+  : ArrayBuilder<N, I, [...H, I]>;

package/typings/common/utility/iterable/build/arrays/index.d.ts

@@ -0,0 +1,2 @@
+declare type Arrayful<I = string> = ArrayN<1, I>;
+declare type Arrayfully<I = string> = ArrayN<2, I>;

package/typings/common/utility/iterable/build/tuples/index.d.ts

@@ -0,0 +1,10 @@
+declare type Monad<I = string> = Tuple<1, I>;
+declare type Dyad<I = string> = Tuple<2, I>;
+declare type Triad<I = string> = Tuple<3, I>;
+declare type Quad<I = string> = Tuple<4, I>;
+declare type Pentad<I = string> = Tuple<5, I>;
+declare type Hexad<I = string> = Tuple<6, I>;
+declare type Heptad<I = string> = Tuple<7, I>;
+declare type Octad<I = string> = Tuple<8, I>;
+declare type Nonad<I = string> = Tuple<9, I>;
+declare type Decad<I = string> = Tuple<10, I>;

package/typings/common/utility/iterable/build/tuples/tuple/index.d.ts

@@ -0,0 +1,26 @@
+declare type Tuple<N extends number = 2, I = string> = [I] extends [never]
+  ? never
+  : N extends number
+    ? N extends 0 /* TODO: constrain posint */
+      ? readonly []
+      : TupleBuilder<N, I>
+    : never;
+
+type TupleBuilder<N extends number, I, H extends readonly I[] = readonly []> = H["length"] extends N
+  ? H
+  : TupleBuilder<N, I, readonly [...H, I]>;
+
+declare namespace Tuple {
+  export type T = Tuple;
+  export type T0 = Tuple<0>;
+  export type T0a = Tuple<1>;
+  export type T0b = Tuple<3>;
+  export type T1 = Tuple<2, string | number>;
+  export type T2 = Tuple<2 | 3>;
+  export type T3 = Tuple<2 | 3, string | number>;
+  export type T4 = Tuple<never>;
+  export type T4a = Tuple<0>;
+  export type T4b = Tuple<0 | 1>;
+  export type T4c = Tuple<1, never>;
+  export type T4d = Tuple<never, never>;
+}

package/typings/{typioca → common}/utility/iterable/identity/array/length/index.d.ts

@@ -7,8 +7,8 @@ declare namespace ArrayLength {
   export type T0d = ArrayLength<readonly string[]>;
   export type T0c = ArrayLength<[string?, string?]>;
   export type T1 = ArrayLength<[string] | [string, string?, string?]>;
-  export type T1b = ArrayLength<[string] | [string?, string?, string?]>; // 0 | 1 | 2 | 3 -- empty Tuple -> length: 0 is just 0, so does not consume other possible lengths
-  export type T1c = ArrayLength<string[] | [string, string, string]>; // 0 -- Array -> length: number coerced to length 0 but consumes all other possible lengths
+  export type T1b = ArrayLength<[string] | [string?, string?, string?]>; // 0 | 1 | 2 | 3 -- empty tuple -> length: 0 is just 0, so does not consume other possible lengths
+  export type T1c = ArrayLength<string[] | [string, string, string]>; // 0 -- array -> length: number coerced to length 0 but consumes all other possible lengths
 }
 
 declare namespace NotArrayLength {

package/typings/{typioca → common}/utility/iterable/identity/monad.d.ts

@@ -12,11 +12,11 @@ declare namespace MonadType {
   export type T6 = MonadType<string[] | int[]>;
   export type T7 = MonadType<(string | int)[]>;
   export type T18 = MonadType<[string] | [5, 10]>;
-  export type T8a = MonadType<Tuple<boolean>>;
-  export type T8b = MonadType<ArrayN<string, 3>>;
+  export type T8a = MonadType<Tuple>;
+  export type T8b = MonadType<ArrayN<3>>;
   export type T8c = MonadType<
-    | ArrayN<string, 3>
-    | Tuple<boolean>
+    | ArrayN<3>
+    | Tuple
     | [string]
     | [5, 10]
     | [5, 13]
@@ -42,7 +42,7 @@ declare namespace NotMonadType {
     | readonly [5, 10]
     | readonly string[]
   >;
-  export type N31 = MonadType<ArrayN<string>>;
+  export type N31 = MonadType<ArrayN>;
   export type N32 = MonadType<[string?]>;
   export type N33 = MonadType<readonly [string?]>;
 }

package/typings/common/utility/iterable/transform/string/stringify/index.d.ts

@@ -0,0 +1,27 @@
+declare type Stringify<C> = C extends abstract new (...args: infer A) => infer O
+  ? O extends { string: infer S extends string }
+    ? S
+    : O extends { toString: () => infer S extends string }
+      ? S
+      : never
+  : C extends ((...args: infer A) => infer S extends string)
+    ? S
+    : C extends { string: infer S extends string }
+      ? S
+      : C extends { toString: () => infer S extends string }
+        ? S
+        : never;
+
+declare namespace Stringify {
+  export type T = Stringify<CharString<"OK-Instance">>;
+  export type T0 = Stringify<CharStringCtor>;
+  export type T1 = Stringify<charstringfunc<"OK-Function">>;
+
+  type CharStringCtor = abstract new () => CharString<"OK-Constructor">;
+
+  interface CharString<Validator extends string> {
+    readonly string: valid<stringful, [Validator, "string"]>;
+  }
+
+  type charstringfunc<Validator extends string> = () => valid<stringful, [Validator, "string"]>;
+}

package/typings/common/utility/nullable/index.spec.d.ts

@@ -0,0 +1,13 @@
+declare namespace Nullable {
+  type OK = Test<TF> | 0;
+  type TF = {
+    T: {
+      T0: Nullable<string>;
+      T1: Nullable<string | null>;
+      T2: Nullable<string | undefined>;
+      T3: Nullable<string | null | undefined>;
+      T4: Nullable<string | int | null>;
+      T6: Nullable<NonNullable<undefined | string>>;
+    };
+  };
+}

package/typings/common/utility/nullable/null/index.spec.d.ts

@@ -0,0 +1,13 @@
+declare namespace _Null {
+  type OK = Test<TF> | 0;
+  type TF = {
+    T: {
+      T0: Null<string>;
+      T1: Null<string | null>;
+      T2: Null<string | undefined>;
+      T3: Null<string | null | undefined>;
+      T4: Null<string | int | null>;
+      T6: Null<NonNullable<undefined | string>>;
+    };
+  };
+}

package/typings/common/utility/test.d.ts

@@ -0,0 +1,2 @@
+declare type Test<TF extends { T: unknown; F?: unknown }> = (OmitNever<TF["T"]> extends TF["T"] ? true : never) & (object extends OmitNever<TF["F"]> ? true : undefined extends OmitNever<TF["F"]> ? true : never);
+declare type OmitNever<R> = { [K in keyof R as R[K] extends never ? never : K]: R[K] };

package/typings/common/valid/index.d.ts

@@ -0,0 +1,7 @@
+declare const v: unique symbol;
+declare type valid<T, V extends readonly string[]> =
+  & T
+  & (Chain<V, ":", true> extends never
+    ? never
+    : { [v]: Chain<V, ":", true> })
+;

package/typings/common/valid/string/index.d.ts

@@ -0,0 +1 @@
+declare type vstring<V extends string> = valid<stringful, [V, "string"]>;

package/dist/factory/options/md.d.ts

@@ -1,9 +0,0 @@
-import Option from "./option/index.js";
-export default class Md extends Option<"md", "markdownlint", false, true, 1> {
-    readonly scope = "md";
-    readonly processor: {};
-    get languageOptions(): {
-        readonly parser: unknown;
-    };
-}
-//# sourceMappingURL=md.d.ts.map

package/dist/factory/options/md.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"md.d.ts","sourceRoot":"","sources":["../../../src/factory/options/md.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,MAAM,CAAC,OAAO,OAAO,EAAG,SAAQ,MAAM,CACpC,IAAI,EACJ,cAAc,EACd,KAAK,EACL,IAAI,EACJ,CAAC,CACF;IACC,SAAgB,KAAK,QAAQ;IAC7B,SAAgB,SAAS,KAAe;IAExC,IAAW,eAAe;;MAIzB;CACF"}

package/dist/factory/options/md.js

@@ -1,10 +0,0 @@
-import Option from "./option/index.js";
-export default class Md extends Option {
-    scope = "md";
-    processor = {};
-    get languageOptions() {
-        const [parser] = this.parser;
-        return { parser };
-    }
-}
-//# sourceMappingURL=md.js.map

package/dist/factory/options/md.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"md.js","sourceRoot":"","sources":["../../../src/factory/options/md.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAC;AAE9B,MAAM,CAAC,OAAO,OAAO,EAAG,SAAQ,MAM/B;IACiB,KAAK,GAAG,IAAI,CAAC;IACb,SAAS,GAAG,EAAW,CAAC;IAExC,IAAW,eAAe;QACxB,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAE7B,OAAO,EAAE,MAAM,EAAW,CAAC;IAC7B,CAAC;CACF"}

package/src/factory/options/md.ts

@@ -1,18 +0,0 @@
-import Option from "./option";
-
-export default class Md extends Option<
-  "md",
-  "markdownlint",
-  false,
-  true,
-  1
-> {
-  public readonly scope = "md";
-  public readonly processor = {} as const;
-
-  public get languageOptions() {
-    const [parser] = this.parser;
-
-    return { parser } as const;
-  }
-}

package/typings/typioca/utility/iterable/build/arrays/array/index.d.ts

@@ -1,12 +0,0 @@
-// TODO: constrain to positive integer
-declare type ArrayN<I, N extends number = 0> = [I] extends [never]
-  ? never
-  : N extends number
-    ? N extends 0
-      ? [...I[]]
-      : ArrayBuilder<I, N>
-    : never;
-
-type ArrayBuilder<I, N extends number, H extends I[] = []> = H["length"] extends N
-  ? [...H, ...I[]]
-  : ArrayBuilder<I, N, [...H, I]>;

package/typings/typioca/utility/iterable/build/arrays/index.d.ts

@@ -1 +0,0 @@
-declare type Arrayful<I> = ArrayN<I, 1>;

package/typings/typioca/utility/iterable/build/tuples/index.d.ts

@@ -1,9 +0,0 @@
-declare type Monad<I> = Tuple<I, 1>;
-declare type Triad<I> = Tuple<I, 3>;
-declare type Quad<I> = Tuple<I, 4>;
-declare type Pentad<I> = Tuple<I, 5>;
-declare type Hexad<I> = Tuple<I, 6>;
-declare type Heptad<I> = Tuple<I, 7>;
-declare type Octad<I> = Tuple<I, 8>;
-declare type Nonad<I> = Tuple<I, 9>;
-declare type Decad<I> = Tuple<I, 10>;

package/typings/typioca/utility/iterable/build/tuples/tuple/index.d.ts

@@ -1,27 +0,0 @@
-// TODO: constrain to positive integer
-declare type Tuple<I, N extends number = 2> = [I] extends [never]
-  ? never
-  : N extends number
-    ? N extends 0
-      ? readonly []
-      : TupleBuilder<I, Numbered<N>>
-    : never;
-
-type TupleBuilder<I, N, H extends readonly I[] = readonly []> = H["length"] extends N
-  ? H
-  : TupleBuilder<I, N, readonly [...H, I]>;
-
-declare namespace Tuple {
-  export type T = Tuple<string>;
-  export type T0 = Tuple<string, 0>;
-  export type T0a = Tuple<string, 1>;
-  export type T0b = Tuple<string, 3>;
-  export type T1 = Tuple<string | number>;
-  export type T2 = Tuple<string, 2 | 3>;
-  export type T3 = Tuple<string | number, 2 | 3>;
-  export type T4 = Tuple<string, never>;
-  export type T4a = Tuple<string, 0>;
-  export type T4b = Tuple<string, 0 | 1>;
-}
-
-type NN = Numbered<5 | 10>;

package/typings/typioca/utility/iterable/transform/string/stringify/index.d.ts

@@ -1,13 +0,0 @@
-declare type Stringify<C> = C extends abstract new (...args: infer A) => infer O
-  ? O extends { string: infer S extends string }
-    ? S
-    : O extends { toString: () => infer S extends string }
-      ? S
-      : never
-  : C extends ((...args: infer A) => infer S extends string)
-    ? S
-    : C extends { string: infer S extends string }
-      ? S
-      : C extends { toString: () => infer S extends string }
-        ? S
-        : never;