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

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "_schemaVersion": "20.18.0",
   "name": "@eslinted/core",
-  "version": "5.0.0-rc.3",
+  "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/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/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/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/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;