eslint-plugin-package-json 0.88.2 → 0.89.0

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/primitive.d.mts

@@ -0,0 +1,23 @@
+import { And } from "../../utils/and.mjs";
+import { DoesExtend } from "../../utils/extends.mjs";
+import { If } from "../../utils/if.mjs";
+import { Never, NeverType } from "../never.mjs";
+import { ConstType } from "../const.mjs";
+import { EnumType } from "../enum.mjs";
+import { ObjectType } from "../object.mjs";
+import { Primitive, PrimitiveType, PrimitiveValue } from "../primitive.mjs";
+import { TupleType } from "../tuple.mjs";
+import { UnionType } from "../union.mjs";
+import { SerializableType, Type } from "../type.mjs";
+import { ArrayType } from "../array.mjs";
+import { AnyType } from "../any.mjs";
+import { DistributeIntersection } from "./union.mjs";
+import { IntersectDeserialized, IntersectIsSerialized } from "./utils.mjs";
+import { IntersectConstToPrimitive } from "./const.mjs";
+import { IntersectEnumToPrimitive } from "./enum.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/primitive.d.ts
+declare type IntersectPrimitiveSerializationParams<META_PRIMITIVE extends PrimitiveType, SERIALIZABLE_META_TYPE extends SerializableType> = Primitive<PrimitiveValue<META_PRIMITIVE>, IntersectIsSerialized<META_PRIMITIVE, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_PRIMITIVE, SERIALIZABLE_META_TYPE>>;
+declare type IntersectPrimitive<META_PRIMITIVE extends PrimitiveType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectPrimitiveSerializationParams<META_PRIMITIVE, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToPrimitive<META_TYPE, META_PRIMITIVE> : META_TYPE extends EnumType ? IntersectEnumToPrimitive<META_TYPE, META_PRIMITIVE> : META_TYPE extends PrimitiveType ? If<And<DoesExtend<PrimitiveValue<META_PRIMITIVE>, PrimitiveValue<META_TYPE>>, DoesExtend<PrimitiveValue<META_TYPE>, PrimitiveValue<META_PRIMITIVE>>>, IntersectPrimitiveSerializationParams<META_PRIMITIVE, META_TYPE>, Never> : META_TYPE extends ArrayType ? Never : META_TYPE extends TupleType ? Never : META_TYPE extends ObjectType ? Never : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_PRIMITIVE> : Never : Never;
+//#endregion
+export { IntersectPrimitive, IntersectPrimitiveSerializationParams };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/tuple.d.mts

@@ -0,0 +1,26 @@
+import { Never, NeverType } from "../never.mjs";
+import { ConstType } from "../const.mjs";
+import { EnumType } from "../enum.mjs";
+import { ObjectType } from "../object.mjs";
+import { PrimitiveType } from "../primitive.mjs";
+import { $Tuple, IsTupleOpen, TupleOpenProps, TupleType, TupleValues } from "../tuple.mjs";
+import { UnionType } from "../union.mjs";
+import { SerializableType, Type } from "../type.mjs";
+import { ArrayType, ArrayValues } from "../array.mjs";
+import { AnyType } from "../any.mjs";
+import { DistributeIntersection } from "./union.mjs";
+import { IntersectDeserialized, IntersectIsSerialized } from "./utils.mjs";
+import { IntersectConstToTuple } from "./const.mjs";
+import { IntersectEnumToTuple } from "./enum.mjs";
+import { $Intersect, Intersect } from "./index.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/tuple.d.ts
+declare type IntersectTupleSerializationParams<VALUES extends Type[], OPEN_PROPS extends Type, META_TUPLE extends TupleType, SERIALIZABLE_META_TYPE extends SerializableType> = $MergeTuplePropsToSerializable<VALUES, OPEN_PROPS, META_TUPLE, SERIALIZABLE_META_TYPE>;
+declare type $MergeTuplePropsToSerializable<VALUES, OPEN_PROPS, META_TUPLE extends TupleType, SERIALIZABLE_META_TYPE extends SerializableType> = $Tuple<VALUES, OPEN_PROPS, IntersectIsSerialized<META_TUPLE, SERIALIZABLE_META_TYPE>, IntersectDeserialized<META_TUPLE, SERIALIZABLE_META_TYPE>>;
+declare type IntersectTuple<META_TUPLE extends TupleType, META_TYPE> = META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? IntersectTupleSerializationParams<TupleValues<META_TUPLE>, TupleOpenProps<META_TUPLE>, META_TUPLE, META_TYPE> : META_TYPE extends ConstType ? IntersectConstToTuple<META_TYPE, META_TUPLE> : META_TYPE extends EnumType ? IntersectEnumToTuple<META_TYPE, META_TUPLE> : META_TYPE extends PrimitiveType ? Never : META_TYPE extends ArrayType ? IntersectTupleToArray<META_TUPLE, META_TYPE> : META_TYPE extends TupleType ? IntersectTuples<META_TUPLE, META_TYPE> : META_TYPE extends ObjectType ? Never : META_TYPE extends UnionType ? DistributeIntersection<META_TYPE, META_TUPLE> : Never;
+declare type IntersectTupleToArray<META_TUPLE extends TupleType, META_ARRAY extends ArrayType, INTERSECTED_VALUES extends unknown[] = IntersectTupleToArrayValues<TupleValues<META_TUPLE>, ArrayValues<META_ARRAY>>, INTERSECTED_OPEN_PROPS = $Intersect<TupleOpenProps<META_TUPLE>, ArrayValues<META_ARRAY>>> = $MergeTuplePropsToSerializable<INTERSECTED_VALUES, INTERSECTED_OPEN_PROPS, META_TUPLE, META_ARRAY>;
+declare type IntersectTupleToArrayValues<TUPLE_VALUES extends Type[], ARRAY_VALUES extends Type, RESULT extends unknown[] = []> = TUPLE_VALUES extends [infer TUPLE_VALUES_HEAD, ...infer TUPLE_VALUES_TAIL] ? TUPLE_VALUES_HEAD extends Type ? TUPLE_VALUES_TAIL extends Type[] ? IntersectTupleToArrayValues<TUPLE_VALUES_TAIL, ARRAY_VALUES, [...RESULT, Intersect<TUPLE_VALUES_HEAD, ARRAY_VALUES>]> : never : never : RESULT;
+declare type IntersectTuples<META_TUPLE_A extends TupleType, META_TUPLE_B extends TupleType, INTERSECTED_VALUES extends unknown[] = IntersectTupleValues<TupleValues<META_TUPLE_A>, TupleValues<META_TUPLE_B>, IsTupleOpen<META_TUPLE_A>, IsTupleOpen<META_TUPLE_B>, TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>, INTERSECTED_OPEN_PROPS = $Intersect<TupleOpenProps<META_TUPLE_A>, TupleOpenProps<META_TUPLE_B>>> = $MergeTuplePropsToSerializable<INTERSECTED_VALUES, INTERSECTED_OPEN_PROPS, META_TUPLE_A, META_TUPLE_B>;
+declare type IntersectTupleValues<TUPLE_A_VALUES extends Type[], TUPLE_B_VALUES extends Type[], TUPLE_A_IS_OPEN extends boolean, TUPLE_B_IS_OPEN extends boolean, TUPLE_A_OPEN_PROPS extends Type, TUPLE_B_OPEN_PROPS extends Type, RESULT extends unknown[] = []> = TUPLE_A_VALUES extends [infer TUPLE_A_VALUES_HEAD, ...infer TUPLE_A_VALUES_TAIL] ? TUPLE_A_VALUES_HEAD extends Type ? TUPLE_A_VALUES_TAIL extends Type[] ? TUPLE_B_VALUES extends [infer TUPLE_B_VALUES_HEAD, ...infer TUPLE_B_VALUES_TAIL] ? TUPLE_B_VALUES_HEAD extends Type ? TUPLE_B_VALUES_TAIL extends Type[] ? IntersectTupleValues<TUPLE_A_VALUES_TAIL, TUPLE_B_VALUES_TAIL, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, Intersect<TUPLE_A_VALUES_HEAD, TUPLE_B_VALUES_HEAD>]> : never : never : IntersectTupleValues<TUPLE_A_VALUES_TAIL, TUPLE_B_VALUES, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, TUPLE_B_IS_OPEN extends true ? Intersect<TUPLE_A_VALUES_HEAD, TUPLE_B_OPEN_PROPS> : Never]> : never : never : TUPLE_B_VALUES extends [infer TUPLE_B_VALUES_HEAD, ...infer TUPLE_B_VALUES_TAIL] ? TUPLE_B_VALUES_HEAD extends Type ? TUPLE_B_VALUES_TAIL extends Type[] ? IntersectTupleValues<TUPLE_A_VALUES, TUPLE_B_VALUES_TAIL, TUPLE_A_IS_OPEN, TUPLE_B_IS_OPEN, TUPLE_A_OPEN_PROPS, TUPLE_B_OPEN_PROPS, [...RESULT, TUPLE_A_IS_OPEN extends true ? Intersect<TUPLE_B_VALUES_HEAD, TUPLE_A_OPEN_PROPS> : Never]> : never : never : RESULT;
+//#endregion
+export { IntersectTuple, IntersectTupleSerializationParams, IntersectTupleToArray };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/union.d.mts

@@ -0,0 +1,17 @@
+import { Never, NeverType } from "../never.mjs";
+import { ConstType } from "../const.mjs";
+import { EnumType } from "../enum.mjs";
+import { ObjectType } from "../object.mjs";
+import { PrimitiveType } from "../primitive.mjs";
+import { TupleType } from "../tuple.mjs";
+import { $Union, UnionType, UnionValues } from "../union.mjs";
+import { Type } from "../type.mjs";
+import { ArrayType } from "../array.mjs";
+import { AnyType } from "../any.mjs";
+import { $Intersect } from "./index.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/union.d.ts
+declare type IntersectUnion<META_UNION extends UnionType, META_TYPE> = META_TYPE extends Type ? META_TYPE extends NeverType ? META_TYPE : META_TYPE extends AnyType ? META_UNION : META_TYPE extends ConstType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends EnumType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends PrimitiveType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends ArrayType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends TupleType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends ObjectType ? DistributeIntersection<META_UNION, META_TYPE> : META_TYPE extends UnionType ? DistributeIntersection<META_UNION, META_TYPE> : Never : Never;
+declare type DistributeIntersection<META_UNION extends UnionType, META_TYPE> = $Union<UnionValues<META_UNION> extends infer UNION_VALUE ? $Intersect<UNION_VALUE, META_TYPE> : never>;
+//#endregion
+export { DistributeIntersection, IntersectUnion };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/utils.d.mts

@@ -0,0 +1,10 @@
+import { If } from "../../utils/if.mjs";
+import { Or } from "../../utils/or.mjs";
+import { Deserialized, IsSerialized } from "../utils.mjs";
+import { SerializableType } from "../type.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/utils.d.ts
+declare type IntersectIsSerialized<SERIALIZABLE_META_TYPE_A extends SerializableType, SERIALIZABLE_META_TYPE_B extends SerializableType> = Or<IsSerialized<SERIALIZABLE_META_TYPE_A>, IsSerialized<SERIALIZABLE_META_TYPE_B>>;
+declare type IntersectDeserialized<SERIALIZABLE_META_TYPE_A extends SerializableType, SERIALIZABLE_META_TYPE_B extends SerializableType> = If<IsSerialized<SERIALIZABLE_META_TYPE_A>, If<IsSerialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_A> & Deserialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_A>>, If<IsSerialized<SERIALIZABLE_META_TYPE_B>, Deserialized<SERIALIZABLE_META_TYPE_B>>>;
+//#endregion
+export { IntersectDeserialized, IntersectIsSerialized };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.d.mts

@@ -0,0 +1,9 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.d.ts
+declare type NeverTypeId = "never";
+declare type Never = {
+  type: NeverTypeId;
+};
+declare type NeverType = Never;
+declare type ResolveNever = never;
+//#endregion
+export { Never, NeverType, ResolveNever };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/object.d.mts

@@ -0,0 +1,49 @@
+import { And } from "../utils/and.mjs";
+import { DoesExtend } from "../utils/extends.mjs";
+import { If } from "../utils/if.mjs";
+import { IsNever } from "../utils/isNever.mjs";
+import { DeepMergeUnsafe } from "../utils/merge.mjs";
+import { Not } from "../utils/not.mjs";
+import { Never, NeverType } from "./never.mjs";
+import { Deserialized, IsSerialized } from "./utils.mjs";
+import { Type } from "./type.mjs";
+import { Resolve, ResolveOptions } from "./resolve.mjs";
+import { Any } from "./any.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/object.d.ts
+declare type ObjectTypeId = "object";
+declare type _Object<VALUES extends Record<string, Type> = {}, REQUIRED_KEYS extends string = never, OPEN_PROPS extends Type = Never, CLOSE_ON_RESOLVE extends boolean = false, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = _$Object<VALUES, REQUIRED_KEYS, OPEN_PROPS, CLOSE_ON_RESOLVE, IS_SERIALIZED, DESERIALIZED>;
+declare type _$Object<VALUES = {}, REQUIRED_KEYS = never, OPEN_PROPS = Never, CLOSE_ON_RESOLVE = false, IS_SERIALIZED = false, DESERIALIZED = never> = DoesExtend<true, { [KEY in Extract<REQUIRED_KEYS, string>]: KEY extends keyof VALUES ? DoesExtend<VALUES[KEY], NeverType> : DoesExtend<OPEN_PROPS, NeverType> }[Extract<REQUIRED_KEYS, string>]> extends true ? Never : {
+  type: ObjectTypeId;
+  values: VALUES;
+  required: REQUIRED_KEYS;
+  isOpen: Not<DoesExtend<OPEN_PROPS, NeverType>>;
+  openProps: OPEN_PROPS;
+  closeOnResolve: CLOSE_ON_RESOLVE;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type ObjectType = {
+  type: ObjectTypeId;
+  values: Record<string, Type>;
+  required: string;
+  isOpen: boolean;
+  openProps: Type;
+  closeOnResolve: boolean;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type ObjectValues<META_OBJECT extends ObjectType> = META_OBJECT["values"];
+declare type ObjectValue<META_OBJECT extends ObjectType, KEY extends string> = KEY extends keyof ObjectValues<META_OBJECT> ? ObjectValues<META_OBJECT>[KEY] : IsObjectOpen<META_OBJECT> extends true ? ObjectOpenProps<META_OBJECT> : Never;
+declare type ObjectRequiredKeys<META_OBJECT extends ObjectType> = META_OBJECT["required"];
+declare type IsObjectOpen<META_OBJECT extends ObjectType> = META_OBJECT["isOpen"];
+declare type ObjectOpenProps<META_OBJECT extends ObjectType> = META_OBJECT["openProps"];
+declare type IsObjectClosedOnResolve<META_OBJECT extends ObjectType> = META_OBJECT["closeOnResolve"];
+declare type IsObjectEmpty<META_OBJECT extends ObjectType> = IsNever<keyof ObjectValues<META_OBJECT>>;
+declare type ResolveObject<META_OBJECT extends ObjectType, OPTIONS extends ResolveOptions> = If<And<OPTIONS["deserialize"], IsSerialized<META_OBJECT>>, Deserialized<META_OBJECT>, DeepMergeUnsafe<If<And<IsObjectOpen<META_OBJECT>, Not<IsObjectClosedOnResolve<META_OBJECT>>>, If<IsObjectEmpty<META_OBJECT>, {
+  [KEY: string]: Resolve<ObjectOpenProps<META_OBJECT>, OPTIONS>;
+}, {
+  [KEY: string]: Resolve<Any, OPTIONS>;
+}>, {}>, DeepMergeUnsafe<{ [KEY in Exclude<keyof ObjectValues<META_OBJECT>, ObjectRequiredKeys<META_OBJECT>>]?: Resolve<ObjectValues<META_OBJECT>[KEY], OPTIONS> }, { [KEY in ObjectRequiredKeys<META_OBJECT>]: KEY extends keyof ObjectValues<META_OBJECT> ? Resolve<ObjectValues<META_OBJECT>[KEY], OPTIONS> : Resolve<Any, OPTIONS> }>>>;
+//#endregion
+export { IsObjectClosedOnResolve, IsObjectOpen, ObjectOpenProps, ObjectRequiredKeys, ObjectType, ObjectValue, ObjectValues, ResolveObject, _$Object, _Object };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/primitive.d.mts

@@ -0,0 +1,26 @@
+import { And } from "../utils/and.mjs";
+import { If } from "../utils/if.mjs";
+import { IsNever } from "../utils/isNever.mjs";
+import { Never } from "./never.mjs";
+import { Deserialized, IsSerialized } from "./utils.mjs";
+import { ResolveOptions } from "./resolve.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/primitive.d.ts
+declare type PrimitiveTypeId = "primitive";
+declare type Primitive<VALUE extends null | boolean | number | string, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = $Primitive<VALUE, IS_SERIALIZED, DESERIALIZED>;
+declare type $Primitive<VALUE, IS_SERIALIZED = false, DESERIALIZED = never> = If<IsNever<VALUE>, Never, {
+  type: PrimitiveTypeId;
+  value: VALUE;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+}>;
+declare type PrimitiveType = {
+  type: PrimitiveTypeId;
+  value: null | boolean | number | string;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type PrimitiveValue<META_PRIMITIVE extends PrimitiveType> = META_PRIMITIVE["value"];
+declare type ResolvePrimitive<META_PRIMITIVE extends PrimitiveType, OPTIONS extends ResolveOptions> = If<And<OPTIONS["deserialize"], IsSerialized<META_PRIMITIVE>>, Deserialized<META_PRIMITIVE>, PrimitiveValue<META_PRIMITIVE>>;
+//#endregion
+export { Primitive, PrimitiveType, PrimitiveValue, ResolvePrimitive };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/resolve.d.mts

@@ -0,0 +1,22 @@
+import { NeverType, ResolveNever } from "./never.mjs";
+import { ConstType, ResolveConst } from "./const.mjs";
+import { EnumType, ResolveEnum } from "./enum.mjs";
+import { ObjectType, ResolveObject } from "./object.mjs";
+import { PrimitiveType, ResolvePrimitive } from "./primitive.mjs";
+import { ResolveTuple, TupleType } from "./tuple.mjs";
+import { ResolveUnion, UnionType } from "./union.mjs";
+import { Type } from "./type.mjs";
+import { ArrayType, ResolveArray } from "./array.mjs";
+import { AnyType, ResolveAny } from "./any.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/resolve.d.ts
+declare type ResolveOptions = {
+  deserialize: boolean;
+};
+declare type ResolveDefaultOptions = {
+  deserialize: true;
+};
+declare type Resolve<META_TYPE extends Type, OPTIONS extends ResolveOptions = ResolveDefaultOptions> = $Resolve<META_TYPE, OPTIONS>;
+declare type $Resolve<META_TYPE, OPTIONS extends ResolveOptions = ResolveDefaultOptions> = META_TYPE extends AnyType ? ResolveAny<META_TYPE, OPTIONS> : META_TYPE extends NeverType ? ResolveNever : META_TYPE extends ConstType ? ResolveConst<META_TYPE, OPTIONS> : META_TYPE extends EnumType ? ResolveEnum<META_TYPE, OPTIONS> : META_TYPE extends PrimitiveType ? ResolvePrimitive<META_TYPE, OPTIONS> : META_TYPE extends ArrayType ? ResolveArray<META_TYPE, OPTIONS> : META_TYPE extends TupleType ? ResolveTuple<META_TYPE, OPTIONS> : META_TYPE extends ObjectType ? ResolveObject<META_TYPE, OPTIONS> : META_TYPE extends UnionType ? ResolveUnion<META_TYPE, OPTIONS> : never;
+//#endregion
+export { $Resolve, Resolve, ResolveOptions };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/tuple.d.mts

@@ -0,0 +1,36 @@
+import { And } from "../utils/and.mjs";
+import { DoesExtend } from "../utils/extends.mjs";
+import { If } from "../utils/if.mjs";
+import { Not } from "../utils/not.mjs";
+import { Never, NeverType } from "./never.mjs";
+import { Deserialized, IsSerialized } from "./utils.mjs";
+import { Type } from "./type.mjs";
+import { Resolve, ResolveOptions } from "./resolve.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/tuple.d.ts
+declare type TupleTypeId = "tuple";
+declare type Tuple<VALUES extends Type[], OPEN_PROPS extends Type = Never, IS_SERIALIZED extends boolean = false, DESERIALIZED = never> = $Tuple<VALUES, OPEN_PROPS, IS_SERIALIZED, DESERIALIZED>;
+declare type $Tuple<VALUES, OPEN_PROPS = Never, IS_SERIALIZED = false, DESERIALIZED = never> = IsAnyValueNever<VALUES> extends true ? Never : {
+  type: TupleTypeId;
+  values: VALUES;
+  isOpen: Not<DoesExtend<OPEN_PROPS, NeverType>>;
+  openProps: OPEN_PROPS;
+  isSerialized: IS_SERIALIZED;
+  deserialized: DESERIALIZED;
+};
+declare type IsAnyValueNever<TUPLE> = TUPLE extends [infer TUPLE_HEAD, ...infer TUPLE_TAIL] ? TUPLE_HEAD extends NeverType ? true : IsAnyValueNever<TUPLE_TAIL> : false;
+declare type TupleType = {
+  type: TupleTypeId;
+  values: Type[];
+  isOpen: boolean;
+  openProps: Type;
+  isSerialized: boolean;
+  deserialized: unknown;
+};
+declare type TupleValues<META_TUPLE extends TupleType> = META_TUPLE["values"];
+declare type IsTupleOpen<META_TUPLE extends TupleType> = META_TUPLE["isOpen"];
+declare type TupleOpenProps<META_TUPLE extends TupleType> = META_TUPLE["openProps"];
+declare type ResolveTuple<META_TUPLE extends TupleType, OPTIONS extends ResolveOptions> = If<And<OPTIONS["deserialize"], IsSerialized<META_TUPLE>>, Deserialized<META_TUPLE>, If<IsTupleOpen<META_TUPLE>, [...RecurseOnTuple<TupleValues<META_TUPLE>, OPTIONS>, ...Resolve<TupleOpenProps<META_TUPLE>, OPTIONS>[]], RecurseOnTuple<TupleValues<META_TUPLE>, OPTIONS>>>;
+declare type RecurseOnTuple<VALUES extends Type[], OPTIONS extends ResolveOptions, RESULT extends unknown[] = []> = VALUES extends [infer VALUES_HEAD, ...infer VALUES_TAIL] ? VALUES_HEAD extends Type ? VALUES_TAIL extends Type[] ? RecurseOnTuple<VALUES_TAIL, OPTIONS, [...RESULT, Resolve<VALUES_HEAD, OPTIONS>]> : never : never : RESULT;
+//#endregion
+export { $Tuple, IsTupleOpen, ResolveTuple, Tuple, TupleOpenProps, TupleType, TupleValues };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/type.d.mts

@@ -0,0 +1,18 @@
+import { NeverType } from "./never.mjs";
+import { ConstType } from "./const.mjs";
+import { EnumType } from "./enum.mjs";
+import { ObjectType } from "./object.mjs";
+import { PrimitiveType } from "./primitive.mjs";
+import { TupleType } from "./tuple.mjs";
+import { UnionType } from "./union.mjs";
+import { ArrayType } from "./array.mjs";
+import { AnyType } from "./any.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/type.d.ts
+declare type Type = NeverType | AnyType | ConstType | EnumType | PrimitiveType | ArrayType | TupleType | ObjectType | UnionType;
+declare type SerializableType = Type extends infer META_TYPE ? META_TYPE extends {
+  isSerialized: boolean;
+  deserialized: unknown;
+} ? META_TYPE : never : never;
+//#endregion
+export { SerializableType, Type };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.d.mts

@@ -0,0 +1,23 @@
+import { DoesExtend } from "../utils/extends.mjs";
+import { If } from "../utils/if.mjs";
+import { IsNever } from "../utils/isNever.mjs";
+import { Never, NeverType } from "./never.mjs";
+import { Type } from "./type.mjs";
+import { $Resolve, ResolveOptions } from "./resolve.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.d.ts
+declare type UnionTypeId = "union";
+declare type Union<VALUES extends Type> = $Union<VALUES>;
+declare type $Union<VALUES> = If<IsNever<VALUES>, Never, DoesExtend<VALUES, NeverType> extends true ? Never : {
+  type: UnionTypeId;
+  values: VALUES;
+}>;
+declare type UnionType = {
+  type: UnionTypeId;
+  values: Type;
+};
+declare type UnionValues<META_UNION extends UnionType> = META_UNION["values"];
+declare type ResolveUnion<META_UNION extends UnionType, OPTIONS extends ResolveOptions> = RecurseOnUnion<UnionValues<META_UNION>, OPTIONS>;
+declare type RecurseOnUnion<VALUES extends Type, OPTIONS extends ResolveOptions> = VALUES extends infer META_TYPE ? $Resolve<META_TYPE, OPTIONS> : never;
+//#endregion
+export { $Union, ResolveUnion, Union, UnionType, UnionValues };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/utils.d.mts

@@ -0,0 +1,7 @@
+import { SerializableType } from "./type.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/utils.d.ts
+declare type IsSerialized<SERIALIZABLE_META_TYPE extends SerializableType> = SERIALIZABLE_META_TYPE["isSerialized"];
+declare type Deserialized<SERIALIZABLE_META_TYPE extends SerializableType> = SERIALIZABLE_META_TYPE["deserialized"];
+//#endregion
+export { Deserialized, IsSerialized };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/and.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/and.d.ts
+declare type And<BOOL_A, BOOL_B> = BOOL_A extends true ? BOOL_B extends true ? true : false : false;
+//#endregion
+export { And };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/extends.d.mts

@@ -0,0 +1,7 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/extends.d.ts
+declare type DoesExtend<TYPE_A, TYPE_B> = [TYPE_A] extends [TYPE_B] ? true : false;
+declare type ArrayKeys = keyof [];
+declare type IsObject<TYPE> = TYPE extends object ? ArrayKeys extends Extract<keyof TYPE, ArrayKeys> ? false : true : false;
+declare type IsArray<TYPE> = TYPE extends object ? ArrayKeys extends Extract<keyof TYPE, ArrayKeys> ? true : false : false;
+//#endregion
+export { DoesExtend, IsArray, IsObject };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/if.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/if.d.ts
+declare type If<CONDITION extends boolean, THEN, ELSE = never> = CONDITION extends true ? THEN : ELSE;
+//#endregion
+export { If };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/intersectUnion.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/intersectUnion.d.ts
+declare type IntersectUnion<UNION> = (UNION extends unknown ? (arg: UNION) => void : never) extends ((arg: infer INTERSECTION) => void) ? INTERSECTION : never;
+//#endregion
+export { IntersectUnion };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/isNever.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/isNever.d.ts
+declare type IsNever<TYPE> = [TYPE] extends [never] ? true : false;
+//#endregion
+export { IsNever };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/merge.d.mts

@@ -0,0 +1,6 @@
+import { IsArray, IsObject } from "./extends.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/merge.d.ts
+declare type DeepMergeUnsafe<TYPE_A, TYPE_B> = IsObject<TYPE_A> extends true ? IsObject<TYPE_B> extends true ? { [KEY in keyof (TYPE_A & TYPE_B)]: KEY extends keyof TYPE_B ? KEY extends keyof TYPE_A ? DeepMergeUnsafe<TYPE_A[KEY], TYPE_B[KEY]> : TYPE_B[KEY] : KEY extends keyof TYPE_A ? TYPE_A[KEY] : never } : TYPE_B : IsArray<TYPE_A> extends true ? IsArray<TYPE_B> extends true ? TYPE_B extends unknown[] ? [...(TYPE_A extends unknown[] ? TYPE_A : never), TYPE_B] : never : TYPE_B : TYPE_B;
+//#endregion
+export { DeepMergeUnsafe };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/not.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/not.d.ts
+declare type Not<BOOL extends boolean> = BOOL extends false ? true : BOOL extends true ? false : never;
+//#endregion
+export { Not };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/or.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/or.d.ts
+declare type Or<BOOL_A extends boolean, BOOL_B extends boolean> = BOOL_A extends true ? true : BOOL_B extends true ? true : false;
+//#endregion
+export { Or };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/prettify.d.mts

@@ -0,0 +1,6 @@
+import { IsObject } from "./extends.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/prettify.d.ts
+declare type Prettify<TYPE> = IsObject<TYPE> extends true ? { [KEY in keyof TYPE]: KEY extends keyof TYPE ? TYPE[KEY] : never } : TYPE;
+//#endregion
+export { Prettify };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/tail.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/tail.d.ts
+declare type Tail<ARRAY extends unknown[]> = ARRAY extends readonly [] ? ARRAY : ARRAY extends readonly [unknown?, ...infer TAIL] ? TAIL : ARRAY;
+//#endregion
+export { Tail };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/unionLast.d.mts

@@ -0,0 +1,6 @@
+import { IntersectUnion } from "./intersectUnion.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/unionLast.d.ts
+declare type UnionLast<UNION> = IntersectUnion<UNION extends unknown ? (x: UNION) => void : never> extends ((x: infer LAST) => void) ? LAST : never;
+//#endregion
+export { UnionLast };

package/lib/node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/unionPop.d.mts

@@ -0,0 +1,6 @@
+import { UnionLast } from "./unionLast.mjs";
+
+//#region node_modules/.pnpm/ts-algebra@2.0.0/node_modules/ts-algebra/lib/utils/unionPop.d.ts
+declare type UnionPop<UNION> = Exclude<UNION, UnionLast<UNION>>;
+//#endregion
+export { UnionPop };

package/lib/plugin.d.mts

@@ -1,13 +1,12 @@
+import { JSONSchema } from "./node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.mjs";
 import { PackageJsonRuleModule } from "./createRule.mjs";
 import * as parserJsonc from "jsonc-eslint-parser";
-import * as json_schema_to_ts0 from "json-schema-to-ts";
 import { ESLint } from "eslint";
 
 //#region src/plugin.d.ts
 declare const plugin: {
   configs: {
-    /** @deprecated please use the recommended (flat) config. This will be removed in early 2026 */
-    "legacy-recommended": {
+    /** @deprecated please use the recommended (flat) config. This will be removed in early 2026 */"legacy-recommended": {
       plugins: string[];
       rules: {
         [k: string]: "error";
@@ -57,7 +56,7 @@ declare const plugin: {
     name: string;
     version: string;
   };
-  rules: Record<string, PackageJsonRuleModule<unknown[], json_schema_to_ts0.JSONSchema[]>>;
+  rules: Record<string, PackageJsonRuleModule<unknown[], JSONSchema[]>>;
 };
 //#endregion
 export { plugin };

package/lib/plugin.mjs

@@ -45,12 +45,12 @@ const rules = {
 	"valid-repository-directory": rule$16,
 	"valid-version": rule$17
 };
-const recommendedRules = { ...Object.fromEntries(Object.entries(rules).filter(([, rule$18]) => rule$18.meta.docs?.recommended).map(([name$1]) => ["package-json/" + name$1, "error"])) };
+const recommendedRules = { ...Object.fromEntries(Object.entries(rules).filter(([, rule]) => rule.meta.docs?.recommended).map(([name]) => ["package-json/" + name, "error"])) };
 const recommendedPublishableRules = {
 	...recommendedRules,
-	...Object.fromEntries(Object.entries(rules).filter(([, rule$18]) => rule$18.meta.docs?.category === "Publishable").map(([name$1]) => ["package-json/" + name$1, "error"]))
+	...Object.fromEntries(Object.entries(rules).filter(([, rule]) => rule.meta.docs?.category === "Publishable").map(([name]) => ["package-json/" + name, "error"]))
 };
-const stylisticRules = { ...Object.fromEntries(Object.entries(rules).filter(([, rule$18]) => rule$18.meta.docs?.category === "Stylistic").map(([name$1]) => ["package-json/" + name$1, "error"])) };
+const stylisticRules = { ...Object.fromEntries(Object.entries(rules).filter(([, rule]) => rule.meta.docs?.category === "Stylistic").map(([name]) => ["package-json/" + name, "error"])) };
 const { name, version } = require("../package.json");
 const plugin = {
 	configs: {

package/lib/rules/no-empty-fields.mjs

@@ -69,8 +69,8 @@ const rule = createRule({
 		},
 		hasSuggestions: true,
 		messages: {
-			emptyExpression: "This {{expressionType}} does nothing and can be removed.",
-			emptyFields: "The field '{{field}}' does nothing and can be removed.",
+			emptyExpression: "This {{ expressionType }} does nothing and can be removed.",
+			emptyFields: "The field '{{ field }}' does nothing and can be removed.",
 			remove: "Remove this empty field."
 		},
 		schema: [{

package/lib/rules/repository-shorthand.mjs

@@ -50,10 +50,10 @@ const rule = createRule({
 		function validateRepositoryForShorthand(node) {
 			if (isJSONStringLiteral(node.value)) {
 				const { value } = node.value;
-				const provider$1 = getProviderFromUrl(value);
-				if (provider$1) context.report({
+				const provider = getProviderFromUrl(value);
+				if (provider) context.report({
 					fix(fixer) {
-						return fixer.replaceText(node.value, JSON.stringify(createShorthand(value, provider$1)));
+						return fixer.replaceText(node.value, JSON.stringify(createShorthand(value, provider)));
 					},
 					messageId: "preferShorthand",
 					node: node.value

package/lib/rules/require-attribution.d.mts

@@ -2,10 +2,15 @@ import { PackageJsonRuleModule } from "../createRule.mjs";
 
 //#region src/rules/require-attribution.d.ts
 declare const rule: PackageJsonRuleModule<[({
+  ignorePrivate?: boolean | undefined;
   preferContributorsOnly?: boolean | undefined;
 } | undefined)?], [{
   readonly additionalProperties: false;
   readonly properties: {
+    readonly ignorePrivate: {
+      readonly description: "Skip attribution requirements for packages with `\"private\": true`.";
+      readonly type: "boolean";
+    };
     readonly preferContributorsOnly: {
       readonly description: "Require that only `contributors` is present, and `author` is not defined.";
       readonly type: "boolean";

package/lib/rules/require-attribution.mjs

@@ -5,8 +5,10 @@ import { fixRemoveObjectProperty } from "eslint-fix-utils";
 const rule = createRule({
 	create(context) {
 		const preferContributorsOnly = context.options[0]?.preferContributorsOnly ?? false;
+		const ignorePrivate = context.options[0]?.ignorePrivate ?? true;
 		let authorPropertyNode;
 		let contributorsPropertyNode;
+		let isPrivatePackage = false;
 		return {
 			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=author]"(node) {
 				authorPropertyNode = node;
@@ -19,7 +21,11 @@ const rule = createRule({
 					node
 				});
 			},
+			"Program > JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=private]"(node) {
+				if (node.value.type === "JSONLiteral" && node.value.value === true) isPrivatePackage = true;
+			},
 			"Program:exit"(node) {
+				if (ignorePrivate && isPrivatePackage) return;
 				if (preferContributorsOnly) {
 					if (authorPropertyNode) context.report({
 						messageId: "contributorsOnly",
@@ -41,10 +47,14 @@ const rule = createRule({
 		};
 	},
 	meta: {
-		defaultOptions: [{ preferContributorsOnly: false }],
+		defaultOptions: [{
+			ignorePrivate: true,
+			preferContributorsOnly: false
+		}],
 		docs: {
-			category: "Publishable",
-			description: "Ensures that proper attribution is included, requiring that either `author` or `contributors` is defined, and that if `contributors` is present, it should include at least one contributor."
+			category: "Best Practices",
+			description: "Ensures that proper attribution is included, requiring that either `author` or `contributors` is defined, and that if `contributors` is present, it should include at least one contributor.",
+			recommended: true
 		},
 		hasSuggestions: true,
 		messages: {
@@ -56,10 +66,16 @@ const rule = createRule({
 		},
 		schema: [{
 			additionalProperties: false,
-			properties: { preferContributorsOnly: {
-				description: "Require that only `contributors` is present, and `author` is not defined.",
-				type: "boolean"
-			} },
+			properties: {
+				ignorePrivate: {
+					description: "Skip attribution requirements for packages with `\"private\": true`.",
+					type: "boolean"
+				},
+				preferContributorsOnly: {
+					description: "Require that only `contributors` is present, and `author` is not defined.",
+					type: "boolean"
+				}
+			},
 			type: "object"
 		}],
 		type: "suggestion"

package/lib/rules/require-properties.mjs

@@ -9,8 +9,14 @@ const propertyConfig = [
 	["description", { isRecommended: true }],
 	["devDependencies"],
 	["engines"],
-	["exports", { category: "Publishable" }],
-	["files", { category: "Publishable" }],
+	["exports", {
+		ignorePrivateDefault: true,
+		isRecommended: true
+	}],
+	["files", {
+		ignorePrivateDefault: true,
+		isRecommended: true
+	}],
 	["homepage"],
 	["keywords"],
 	["license", {
@@ -24,11 +30,14 @@ const propertyConfig = [
 	["optionalDependencies"],
 	["peerDependencies"],
 	["repository", {
-		category: "Publishable",
-		ignorePrivateDefault: true
+		ignorePrivateDefault: true,
+		isRecommended: true
 	}],
 	["scripts"],
-	["sideEffects", { category: "Publishable" }],
+	["sideEffects", {
+		ignorePrivateDefault: true,
+		isRecommended: true
+	}],
 	["type", {
 		fixValue: "commonjs",
 		isRecommended: true

package/lib/rules/restrict-private-properties.mjs

@@ -34,8 +34,8 @@ const rule = createRule({
 		fixable: "code",
 		hasSuggestions: true,
 		messages: {
-			removePropertySuggestion: "Remove the '{{property}}' field.",
-			unnecessaryProperty: "The '{{property}}' field is unnecessary in private packages and can be removed."
+			removePropertySuggestion: "Remove the '{{ property }}' field.",
+			unnecessaryProperty: "The '{{ property }}' field is unnecessary in private packages and can be removed."
 		},
 		schema: [{
 			additionalProperties: false,