@eslinted/core 10.0.1 → 10.1.0

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

@@ -183,6 +183,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly CSSMatrixComponent: false;
             readonly CSSMediaRule: false;
             readonly CSSNamespaceRule: false;
+            readonly CSSNestedDeclarations: false;
             readonly CSSNumericArray: false;
             readonly CSSNumericValue: false;
             readonly CSSPageDescriptors: false;
@@ -483,7 +484,6 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly IntersectionObserver: false;
             readonly IntersectionObserverEntry: false;
             readonly isSecureContext: false;
-            readonly Iterator: false;
             readonly Keyboard: false;
             readonly KeyboardEvent: false;
             readonly KeyboardLayoutMap: false;
@@ -1197,6 +1197,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly Intl: false;
             readonly isFinite: false;
             readonly isNaN: false;
+            readonly Iterator: false;
             readonly JSON: false;
             readonly Map: false;
             readonly Math: false;
@@ -1908,6 +1909,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly Intl: false;
             readonly isFinite: false;
             readonly isNaN: false;
+            readonly Iterator: false;
             readonly JSON: false;
             readonly Map: false;
             readonly Math: false;
@@ -2207,6 +2209,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly clearImmediate: false;
             readonly clearInterval: false;
             readonly clearTimeout: false;
+            readonly CloseEvent: false;
             readonly CompressionStream: false;
             readonly console: false;
             readonly CountQueuingStrategy: false;
@@ -2224,7 +2227,6 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly FormData: false;
             readonly global: false;
             readonly Headers: false;
-            readonly Iterator: false;
             readonly MessageChannel: false;
             readonly MessageEvent: false;
             readonly MessagePort: false;
@@ -2281,6 +2283,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly clearImmediate: false;
             readonly clearInterval: false;
             readonly clearTimeout: false;
+            readonly CloseEvent: false;
             readonly CompressionStream: false;
             readonly console: false;
             readonly CountQueuingStrategy: false;
@@ -2297,7 +2300,6 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly FormData: false;
             readonly global: false;
             readonly Headers: false;
-            readonly Iterator: false;
             readonly MessageChannel: false;
             readonly MessageEvent: false;
             readonly MessagePort: false;
@@ -2574,6 +2576,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly ByteLengthQueuingStrategy: false;
             readonly clearInterval: false;
             readonly clearTimeout: false;
+            readonly CloseEvent: false;
             readonly CompressionStream: false;
             readonly console: false;
             readonly CountQueuingStrategy: false;
@@ -2589,7 +2592,6 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly File: false;
             readonly FormData: false;
             readonly Headers: false;
-            readonly Iterator: false;
             readonly MessageChannel: false;
             readonly MessageEvent: false;
             readonly MessagePort: false;
@@ -2801,7 +2803,6 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly importScripts: false;
             readonly indexedDB: false;
             readonly isSecureContext: false;
-            readonly Iterator: false;
             readonly location: false;
             readonly Lock: false;
             readonly LockManager: false;
@@ -2861,6 +2862,7 @@ export default abstract class Option<S extends Scope, Plugin extends keyof Input
             readonly Request: false;
             readonly requestAnimationFrame: false;
             readonly Response: false;
+            readonly RTCDataChannel: false;
             readonly RTCEncodedAudioFrame: false;
             readonly RTCEncodedVideoFrame: false;
             readonly scheduler: false;

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,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"}
+{"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/factory/options/option/template/language/index.d.ts

@@ -1,11 +1,11 @@
 import type { EcmaVersion } from "./ecma.js";
 import type { SourceType } from "./source.js";
-export type LanguageOptions<IsEcma extends boolean, ParserOptions extends object | boolean, GlobalTypes extends string> = (True<IsEcma> extends never ? object : {
+export type LanguageOptions<IsEcma extends boolean, ParserOptions extends object | boolean, GlobalTypes extends string> = (Truth<IsEcma> extends never ? object : {
     ecmaVersion: EcmaVersion;
     sourceType: SourceType;
 }) & (literalful<GlobalTypes> extends never ? object : {
     globals: Record<string, unknown>;
-}) & (ParserOptions extends boolean ? True<ParserOptions> extends never ? object : {
+}) & (ParserOptions extends boolean ? Truth<ParserOptions> extends never ? object : {
     parser: unknown;
 } : ParserOptions extends object ? Interface<ParserOptions> extends never ? object : {
     parser: unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/factory/options/option/template/language/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,OAAO,EACtB,aAAa,SAAS,MAAM,GAAG,OAAO,EACtC,WAAW,SAAS,MAAM,IAEzB,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC,GAC5F,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF,CACC,aAAa,SAAS,OAAO,GACzB,IAAI,CAAC,aAAa,CAAC,SAAS,KAAK,GAC/B,MAAM,GACN;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GACrB,aAAa,SAAS,MAAM,GAC1B,SAAS,CAAC,aAAa,CAAC,SAAS,KAAK,GACpC,MAAM,GACN;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,aAAa,CAAA;CAAE,GACnD,MAAM,CACb,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/factory/options/option/template/language/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,MAAM,eAAe,CACzB,MAAM,SAAS,OAAO,EACtB,aAAa,SAAS,MAAM,GAAG,OAAO,EACtC,WAAW,SAAS,MAAM,IAEzB,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC,GAC7F,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GACvF,CACC,aAAa,SAAS,OAAO,GACzB,KAAK,CAAC,aAAa,CAAC,SAAS,KAAK,GAChC,MAAM,GACN;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GACrB,aAAa,SAAS,MAAM,GAC1B,SAAS,CAAC,aAAa,CAAC,SAAS,KAAK,GACpC,MAAM,GACN;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,aAAa,CAAA;CAAE,GACnD,MAAM,CACb,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "_schemaVersion": "22.10.2",
   "name": "@eslinted/core",
-  "version": "10.0.1",
+  "version": "10.1.0",
   "description": "Core ESLint flat config factory npm package `linted`.",
   "keywords": [],
   "repository": "github:jimmy-zhening-luo/linted-core",
@@ -28,7 +28,7 @@
   },
   "peerDependenciesMeta": {},
   "dependencies": {
-    "globals": "^15.11.0"
+    "globals": "^15.12.0"
   },
   "devDependencies": {
     "@types/chai": "^5.0.1",

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

@@ -6,11 +6,11 @@ export type LanguageOptions<
   ParserOptions extends object | boolean,
   GlobalTypes extends string,
 > =
- & (True<IsEcma> extends never ? object : { ecmaVersion: EcmaVersion; sourceType: SourceType })
+ & (Truth<IsEcma> extends never ? object : { ecmaVersion: EcmaVersion; sourceType: SourceType })
  & (literalful<GlobalTypes> extends never ? object : { globals: Record<string, unknown> })
  & (
     ParserOptions extends boolean
-      ? True<ParserOptions> extends never
+      ? Truth<ParserOptions> extends never
         ? object
         : { parser: unknown }
       : ParserOptions extends object

package/typings/common/literals/chars/alpha.d.ts

@@ -0,0 +1,4 @@
+declare type alpha =
+  | lower
+  | upper
+;

package/typings/common/literals/{string/letter/digit/extended/base64/index.d.ts → chars/digits/base64.d.ts}

@@ -1,5 +1,5 @@
 declare type base64char =
-  | letter
+  | alpha
   | digit
   | "+"
   | "/"

package/typings/common/literals/chars/lower.d.ts

@@ -0,0 +1 @@
+declare type lower = Lowercase<upper>;

package/typings/common/literals/{string/letter/index.d.ts → chars/upper.d.ts}

@@ -1,10 +1,3 @@
-declare type letter =
-  | lower
-  | upper
-;
-
-declare type lower = Lowercase<upper>;
-
 declare type upper =
   | "A"
   | "B"

package/typings/common/literals/{number/bases → numbers}/base32.d.ts

@@ -1,5 +1,5 @@
 declare type base32 =
-  | hex
+  | hexadecimal
   | 16
   | 17
   | 18

package/typings/common/literals/{number/bases/hex.d.ts → numbers/hexadecimal.d.ts}

@@ -1,4 +1,4 @@
-declare type hex =
+declare type hexadecimal =
   | decimal
   | 9
   | 10

package/typings/common/tester.d.ts

@@ -0,0 +1,8 @@
+declare type Tester<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/utility/interface/identity.d.ts

@@ -0,0 +1,11 @@
+declare type Interface<R extends object> = [R] extends [object]
+  ? [Extract<R, readonly unknown[]>] extends [never]
+      ? Required<R> extends Record<infer K, unknown>
+        ? Exclude<K, string> extends never
+          ? literalful<K & string> extends never
+            ? never
+            : R
+          : never
+        : never
+      : never
+  : never;

package/typings/common/utility/interface/{identity/interface/index.d.ts → identity.spec.d.ts}

@@ -1,16 +1,4 @@
-declare type Interface<R extends object> = [R] extends [object]
-  ? [Extract<R, readonly unknown[]>] extends [never]
-      ? Required<R> extends Record<infer K, unknown>
-        ? Exclude<K, string> extends never
-          ? literalful<K & string> extends never
-            ? never
-            : R
-          : never
-        : never
-      : never
-  : never;
-
-declare namespace InterfaceTest {
+declare namespace Interface {
   export type T = Interface<{ a: 5 }>;
   export type T0 = Interface<{
     a: 1;
@@ -22,9 +10,6 @@ declare namespace InterfaceTest {
   }>;
   export type T2 = Interface<Record<"a", unknown>>;
   export type T3 = Interface<Record<"a" | "b", unknown>>;
-}
-
-declare namespace NotInterface {
   export type N = Interface<never>;
   export type N0 = Interface<object>;
   export type N0a = Interface<Record<"a" | "b" | 5, unknown>>;
@@ -76,5 +61,3 @@ declare namespace NotInterface {
   // export type N15 = Interface<string | { a: cool }>;
   // export type N15b = Interface<Record<"a" | "b" | string, unknown>>;
 }
-
-type gg = Extract<{ a: 5 }, readonly unknown[]>;

package/typings/common/utility/interface/keys.d.ts

@@ -0,0 +1,3 @@
+declare type Keys<R extends object> = Interface<R> extends never
+  ? never
+  : keyof Interface<R>;

package/typings/common/utility/interface/{identity/keys/index.d.ts → keys.spec.d.ts}

@@ -1,7 +1,3 @@
-declare type Keys<R extends object> = Interface<R> extends never
-  ? never
-  : keyof Interface<R>;
-
 declare namespace Keys {
   const RESULT: {
     positive: typeof POSITIVE | 1;
@@ -35,7 +31,7 @@ declare namespace Keys {
     N2e: Keys<object>;
     N2f: Keys<{
       a: 1;
-      [min]: 1;
+      [ful]: "cool";
     }>;
     N3: Keys<[]>;
     N3a: Keys<readonly [1, 1]>;

package/typings/common/utility/interface/optional.d.ts

@@ -0,0 +1,7 @@
+declare type Optional<R extends object, OK extends string> = Interface<R> extends never
+  ? never
+  : literalful<OK> extends never
+    ? never
+    : OK extends keyof R
+      ? Omit<Interface<R>, literalful<OK>> & Partial<Pick<Interface<R>, literalful<OK>>>
+      : never;

package/typings/common/utility/interface/{transform/partial/unrequire/index.d.ts → optional.spec.d.ts}

@@ -1,13 +1,5 @@
-declare type Unrequire<R extends object, OK extends string> = Interface<R> extends never
-  ? never
-  : literalful<OK> extends never
-    ? never
-    : OK extends keyof R
-      ? Omit<Interface<R>, literalful<OK>> & Partial<Pick<Interface<R>, literalful<OK>>>
-      : never;
-
-declare namespace Unrequire {
-  export type T = Unrequire<{
+declare namespace Optional {
+  export type T = Optional<{
     a: 1;
     b: 1;
     c: 1;
@@ -30,16 +22,13 @@ declare namespace Unrequire {
     c: 1;
     z: 9001;
   } extends T ? true : false; // true
-}
-
-declare namespace NotUnrequire {
   export type N_null = {
     a: 1;
     b: 1;
     c: 1;
-  } extends Unrequire.T ? true : false; // true
+  } extends T ? true : false; // true
   export type N = {
     b: 1;
     c: 1;
-  } extends Unrequire.T ? true : false; // false
+  } extends T ? true : false; // false
 }

package/typings/common/utility/interface/partially.d.ts

@@ -0,0 +1 @@
+declare type Partially<K extends string, V> = Partial<Recordful<K, V>>;

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

@@ -1,8 +1,8 @@
 declare type Property<K extends string, OK extends string, V> = literalful<K> extends never
-  ? Particord<OK, V>
+  ? Partially<OK, V>
   : Recordful<K, V>
     & (
     literalful<OK> extends never
       ? Recordful<K, V>
-      : Particord<OK, V>
+      : Partially<OK, V>
   );

package/typings/common/utility/interface/property/properties.d.ts

@@ -0,0 +1,6 @@
+declare type Field<K extends string, OK extends string = never> = Property<K, OK, string>;
+declare type Flag<OK extends string, K extends string = never> = Property<K, OK, boolean>;
+declare type Limit<K extends string, OK extends string = never> = Property<K, OK, Record<"min" | "max", number>>;
+declare type List<K extends string, OK extends string = never> = Property<K, OK, readonly string[]>;
+declare type Listish<K extends string, OK extends string = never> = Property<K, OK, Unflat>;
+declare type Scalar<K extends string, OK extends string = never> = Property<K, OK, number>;

package/typings/common/utility/interface/table/tables.d.ts

@@ -0,0 +1,5 @@
+declare type FieldTable = Table<string>;
+declare type FlagTable = Table<boolean>;
+declare type ListTable = Table<readonly string[]>;
+declare type ListishTable = Table<Unflat>;
+declare type ScalarTable = Table<number>;

package/typings/common/utility/iterable/arrayful.d.ts

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

package/typings/common/utility/iterable/{transform/flat/unflat/index.d.ts → flat/unflat.d.ts}

@@ -1,3 +1,3 @@
 declare type Unflat<In = string, RO extends boolean = true> = [In] extends [never]
   ? never
-  : In | (True<RO> extends never ? In[] : readonly In[]);
+  : In | (Truth<RO> extends never ? In[] : readonly In[]);

package/typings/common/utility/iterable/identity.d.ts

@@ -0,0 +1 @@
+declare type IsArray<A> = [A] extends [readonly unknown[]] ? A : never;

package/typings/common/utility/iterable/identity.spec.d.ts

@@ -0,0 +1,59 @@
+declare namespace ArrayType {
+  export type T0 = IsArray<[]>;
+  export type T1 = IsArray<[1, 1]>;
+  export type T2 = IsArray<string[]>;
+  export type T3 = IsArray<readonly []>;
+  export type T4 = IsArray<readonly [1, 1]>;
+  export type T5 = IsArray<readonly string[]>;
+  export type T6 = IsArray<[[]]>;
+  export type T7 = IsArray<string[] | int[]>;
+  export type T8 = IsArray<(string | int)[]>;
+  export type T9 = IsArray<
+    | []
+    | [5, 10]
+    | string []
+    | readonly []
+    | readonly [5, 10]
+    | readonly string[]
+  >;
+  export type T10 = IsArray<[1?, ...string[]]>;
+  export type T11 = IsArray<[1] | [1, 2?]>;
+  export type N0 = IsArray<"">;
+  export type N1 = IsArray<"test">;
+  export type N2 = IsArray<string>;
+  export type N3 = IsArray<boolean>;
+  export type N4 = IsArray<true>;
+  export type N5 = IsArray<false>;
+  export type N6 = IsArray<0>;
+  export type N7 = IsArray<1>;
+  export type N8 = IsArray<number>;
+  export type N9 = IsArray<null>;
+  export type N10 = IsArray<undefined>;
+  export type N11 = IsArray<unknown>;
+  export type N12 = IsArray<never>;
+  export type N13 = IsArray<void>;
+  export type N14 = IsArray<() => void>;
+  export type N15 = IsArray<(a: string) => []>;
+  export type N16 = IsArray<Record<string, unknown>>;
+  export type N17 = IsArray<Record<number, 5>>;
+  export type N18 = IsArray<stringful>;
+  export type N19 = IsArray<{ 0: string }>;
+  export type N20 = IsArray<{
+    0: string;
+    length: 1;
+  }>;
+  export type N21 = IsArray<symbol>;
+  export type N22 = IsArray<object>;
+  export type N23 = IsArray<
+    | []
+    | object
+  >;
+  export type N24 = IsArray<
+    | []
+    | string
+  >;
+  export type N25 = IsArray<
+    | []
+    | null
+  >;
+}

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

@@ -1,9 +1,13 @@
 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>
+    ? `${N}` extends `-${string}`
+      ? never
+      : `${N}` extends `${string}.${string}`
+        ? never
+        : N extends 0 /* TODO: constrain to posint */
+          ? [...I[]]
+          : ArrayBuilder<N, I>
     : never;
 
 type ArrayBuilder<N extends number, I, H extends I[] = []> = H["length"] extends N

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

@@ -0,0 +1,18 @@
+declare namespace ArrayN {
+  type T = ArrayN;
+
+  // type T0 = ArrayN<0>; // string[]
+  // type T0a = ArrayN<-0>; // string[]
+  export type T1 = ArrayN<1>;
+  type T2 = ArrayN<2>;
+  type T3 = ArrayN<1.00000>;
+  type Tn = ArrayN<number>; // string[]
+  type Tna = ArrayN<typeof NaN>; // string[]
+  type Tnb = ArrayN<typeof Infinity>; // string[]
+  type F = ArrayN<never>;
+  type F1 = ArrayN<-1>;
+  type F2 = ArrayN<1.1>;
+  type F3 = ArrayN<-1.1>;
+  type F4 = ArrayN<-1.00000>;
+  type F4a = ArrayN<9.999999999>;
+}

package/typings/common/utility/iterable/tuple.d.ts

@@ -0,0 +1,11 @@
+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]>;

package/typings/common/utility/iterable/{build/tuples/tuple/index.d.ts → tuple.spec.d.ts}

@@ -1,15 +1,3 @@
-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>;

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

@@ -1,5 +1,5 @@
-declare namespace _Null {
-  type OK = Test<TF> | 0;
+declare namespace Null {
+  type OK = Tester<TF> | 0;
   type TF = {
     T: {
       T0: Null<string>;

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

@@ -1,5 +1,5 @@
 declare namespace Nullable {
-  type OK = Test<TF> | 0;
+  type OK = Tester<TF> | 0;
   type TF = {
     T: {
       T0: Nullable<string>;

package/typings/common/utility/primitive/index.d.ts

@@ -1,4 +1,4 @@
-declare type Primeval<P extends T, T extends primitive> = [T] extends [primitive]
+declare type Primitive<P extends T, T extends primitive> = [T] extends [primitive]
   ? [P] extends [T]
       ? Extract<P, object> extends never
         ? Exclude<P, T> extends never
@@ -9,34 +9,3 @@ declare type Primeval<P extends T, T extends primitive> = [T] extends [primitive
         : never
       : never
   : never;
-
-declare namespace Primeval {
-  export type T0 = Primeval<"fast", string>;
-  export type T0a = Primeval<"", string>;
-  export type T0b = Primeval<"fast" | "good", string>;
-  export type T0c = Primeval<"fast" | "", string>;
-  export type T1 = Primeval<5, number>;
-  export type T1a = Primeval<0, number>;
-  export type T2 = Primeval<true, boolean>;
-  export type T2a = Primeval<false, boolean>;
-}
-
-declare namespace NotPrimeval {
-  export type N0 = Primeval<string, string>;
-  export type N0a = Primeval<number, number>;
-  export type N0b = Primeval<boolean, boolean>;
-  export type N1 = Primeval<stringful, string>;
-  export type N1b = Primeval<numberful, number>;
-
-  // export type N2 = Primeval<number | 5, number>;
-  // export type N2a = Primeval<string | "good", string>;
-  // export type N2b = Primeval<boolean | true, boolean>;
-  // export type N3 = Primeval<5, number | object>;
-  // export type N3a = Primeval<symbol, symbol>;
-  // export type N3b = Primeval<object, object>;
-  // export type N3c = Primeval<[], readonly unknown[]>;
-  // export type N3d = Primeval<()=> 5, Function>;
-  // export type N3e = Primeval<5, unknown>;
-  // export type N3f = Primeval<true | 10, boolean>;
-  // export type N3g = Primeval<string | "good", string>;
-}

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

@@ -0,0 +1,27 @@
+declare namespace Primitive {
+  export type T0 = Primitive<"fast", string>;
+  export type T0a = Primitive<"", string>;
+  export type T0b = Primitive<"fast" | "good", string>;
+  export type T0c = Primitive<"fast" | "", string>;
+  export type T1 = Primitive<5, number>;
+  export type T1a = Primitive<0, number>;
+  export type T2 = Primitive<true, boolean>;
+  export type T2a = Primitive<false, boolean>;
+  export type N0 = Primitive<string, string>;
+  export type N0a = Primitive<number, number>;
+  export type N0b = Primitive<boolean, boolean>;
+  export type N1 = Primitive<stringful, string>;
+  export type N1b = Primitive<numberful, number>;
+
+  // export type N2 = Primeval<number | 5, number>;
+  // export type N2a = Primeval<string | "good", string>;
+  // export type N2b = Primeval<boolean | true, boolean>;
+  // export type N3 = Primeval<5, number | object>;
+  // export type N3a = Primeval<symbol, symbol>;
+  // export type N3b = Primeval<object, object>;
+  // export type N3c = Primeval<[], readonly unknown[]>;
+  // export type N3d = Primeval<()=> 5, Function>;
+  // export type N3e = Primeval<5, unknown>;
+  // export type N3f = Primeval<true | 10, boolean>;
+  // export type N3g = Primeval<string | "good", string>;
+}

package/typings/common/utility/primitive/length.d.ts

@@ -0,0 +1,5 @@
+declare type LengthValue<N extends number> = [N] extends [number]
+  ? [number] extends [N]
+      ? 0
+      : Numeric<N>
+  : never;

package/typings/common/utility/primitive/{number/length/index.d.ts → length.spec.d.ts}

@@ -1,10 +1,4 @@
-declare type LengthValue<N extends number> = [N] extends [number]
-  ? [number] extends [N]
-      ? 0
-      : Numbered<N>
-  : never;
-
-declare namespace Length {
+declare namespace LengthValue {
   export type T0 = LengthValue<0>;
   export type T0a = LengthValue<0.0>; // 0
   export type T0b = LengthValue<number>; // 0
@@ -13,9 +7,6 @@ declare namespace Length {
   export type T2 = LengthValue<1.1>; // 1.1
   export type T3 = LengthValue<1 | 5>; // 1 | 5
   export type T3b = LengthValue<0 | 1 | 5>; // 0 | 1 | 5
-}
-
-declare namespace NotLength {
   export type N = LengthValue<never>;
 
   // export type N0 = Length<unknown>;

package/typings/common/utility/primitive/literal.d.ts

@@ -0,0 +1 @@
+declare type literal<S extends string> = Primitive<S, string>;

package/typings/common/utility/primitive/{string/literalful/literal/index.d.ts → literal.spec.d.ts}

@@ -1,13 +1,8 @@
-declare type literal<S extends string> = Primeval<S, string>;
-
 declare namespace literal {
   export type T = literal<"">;
   export type T0 = literal<"a">;
   export type T1 = literal<"a" | "b">;
   export type T1b = literal<"a" | "">;
-}
-
-declare namespace Notliteral {
   export type N = literal<never>;
   export type N0 = literal<string>;