eslint-plugin-package-json 1.5.0 → 1.6.1

package/lib/node_modules/.pnpm/@types_estree@1.0.8/node_modules/@types/estree/index.d.mts

@@ -1,438 +0,0 @@
-//#region node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment[] | undefined;
-  trailingComments?: Comment[] | undefined;
-}
-interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation {
-  source?: string | null | undefined;
-  start: Position;
-  end: Position;
-}
-interface Position {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
-export { Expression, ExpressionStatement };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.mts

@@ -1,7 +0,0 @@
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.ts
-type DeserializationPattern = Readonly<{
-  pattern: unknown;
-  output: unknown;
-}>;
-//#endregion
-export { DeserializationPattern };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.mts

@@ -1,20 +0,0 @@
-import { DeserializationPattern } from "./deserializationPattern.mjs";
-import { JSONSchemaReference } from "./jsonSchema.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.ts
-type FromSchemaOptions = {
-  parseNotKeyword?: boolean;
-  parseIfThenElseKeywords?: boolean;
-  keepDefaultedPropertiesOptional?: boolean;
-  references?: JSONSchemaReference[] | false;
-  deserialize?: DeserializationPattern[] | false;
-};
-type FromSchemaDefaultOptions = {
-  parseNotKeyword: false;
-  parseIfThenElseKeywords: false;
-  keepDefaultedPropertiesOptional: false;
-  references: false;
-  deserialize: false;
-};
-//#endregion
-export { FromSchemaDefaultOptions, FromSchemaOptions };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/index.d.mts

@@ -1,11 +0,0 @@
-import { $Resolve } from "../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/resolve.mjs";
-import { DeserializationPattern } from "./definitions/deserializationPattern.mjs";
-import { JSONSchema } from "./definitions/jsonSchema.mjs";
-import { FromSchemaDefaultOptions, FromSchemaOptions } from "./definitions/fromSchemaOptions.mjs";
-import { ParseOptions } from "./parse-options.mjs";
-import { ParseSchema } from "./parse-schema/index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/index.d.ts
-type FromSchema<SCHEMA extends JSONSchema, OPTIONS extends FromSchemaOptions = FromSchemaDefaultOptions> = $Resolve<ParseSchema<SCHEMA, ParseOptions<SCHEMA, OPTIONS>>>;
-//#endregion
-export { FromSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-options.d.mts

@@ -1,16 +0,0 @@
-import { DeserializationPattern } from "./definitions/deserializationPattern.mjs";
-import { JSONSchema, JSONSchemaReference } from "./definitions/jsonSchema.mjs";
-import { FromSchemaDefaultOptions, FromSchemaOptions } from "./definitions/fromSchemaOptions.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-options.d.ts
-type IndexReferencesById<SCHEMA_REFERENCES extends readonly JSONSchemaReference[]> = { [REF_SCHEMA in SCHEMA_REFERENCES[number] as REF_SCHEMA["$id"]]: REF_SCHEMA };
-type ParseOptions<ROOT_SCHEMA extends JSONSchema, OPTIONS extends FromSchemaOptions> = {
-  parseNotKeyword: OPTIONS["parseNotKeyword"] extends boolean ? OPTIONS["parseNotKeyword"] : FromSchemaDefaultOptions["parseNotKeyword"];
-  parseIfThenElseKeywords: OPTIONS["parseIfThenElseKeywords"] extends boolean ? OPTIONS["parseIfThenElseKeywords"] : FromSchemaDefaultOptions["parseIfThenElseKeywords"];
-  keepDefaultedPropertiesOptional: OPTIONS["keepDefaultedPropertiesOptional"] extends boolean ? OPTIONS["keepDefaultedPropertiesOptional"] : FromSchemaDefaultOptions["keepDefaultedPropertiesOptional"];
-  rootSchema: ROOT_SCHEMA;
-  references: OPTIONS["references"] extends JSONSchemaReference[] ? IndexReferencesById<OPTIONS["references"]> : {};
-  deserialize: OPTIONS["deserialize"] extends DeserializationPattern[] | false ? OPTIONS["deserialize"] : FromSchemaDefaultOptions["deserialize"];
-};
-//#endregion
-export { ParseOptions };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.mts

@@ -1,13 +0,0 @@
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { MergeSubSchema } from "./utils.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.ts
-type AllOfSchema = JSONSchema & Readonly<{
-  allOf: readonly JSONSchema[];
-}>;
-type ParseAllOfSchema<ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions> = RecurseOnAllOfSchema<ALL_OF_SCHEMA["allOf"], ALL_OF_SCHEMA, OPTIONS, ParseSchema<Omit<ALL_OF_SCHEMA, "allOf">, OPTIONS>>;
-type RecurseOnAllOfSchema<SUB_SCHEMAS extends readonly JSONSchema[], ROOT_ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions, PARSED_ROOT_ALL_OF_SCHEMA> = SUB_SCHEMAS extends readonly [infer SUB_SCHEMAS_HEAD, ...infer SUB_SCHEMAS_TAIL] ? SUB_SCHEMAS_HEAD extends JSONSchema ? SUB_SCHEMAS_TAIL extends readonly JSONSchema[] ? RecurseOnAllOfSchema<SUB_SCHEMAS_TAIL, ROOT_ALL_OF_SCHEMA, OPTIONS, $Intersect<ParseSchema<MergeSubSchema<Omit<ROOT_ALL_OF_SCHEMA, "allOf">, SUB_SCHEMAS_HEAD>, OPTIONS>, PARSED_ROOT_ALL_OF_SCHEMA>> : never : never : PARSED_ROOT_ALL_OF_SCHEMA;
-//#endregion
-export { AllOfSchema, ParseAllOfSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.mts

@@ -1,14 +0,0 @@
-import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { MergeSubSchema } from "./utils.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.ts
-type AnyOfSchema = JSONSchema & Readonly<{
-  anyOf: readonly JSONSchema[];
-}>;
-type ParseAnyOfSchema<ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions> = $Union<RecurseOnAnyOfSchema<ANY_OF_SCHEMA["anyOf"], ANY_OF_SCHEMA, OPTIONS>>;
-type RecurseOnAnyOfSchema<SUB_SCHEMAS extends readonly JSONSchema[], ROOT_ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = SUB_SCHEMAS extends readonly [infer SUB_SCHEMAS_HEAD, ...infer SUB_SCHEMAS_TAIL] ? SUB_SCHEMAS_HEAD extends JSONSchema ? SUB_SCHEMAS_TAIL extends readonly JSONSchema[] ? RecurseOnAnyOfSchema<SUB_SCHEMAS_TAIL, ROOT_ANY_OF_SCHEMA, OPTIONS, RESULT | $Intersect<ParseSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
-//#endregion
-export { AnyOfSchema, ParseAnyOfSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.mts

@@ -1,58 +0,0 @@
-import { Never } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
-import { $Tuple } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/tuple.mjs";
-import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
-import { _$Array } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/array.mjs";
-import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { And } from "../type-utils/and.mjs";
-import { DoesExtend } from "../type-utils/extends.mjs";
-import { Not } from "../type-utils/not.mjs";
-import { Tail } from "../type-utils/tail.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.ts
-type ArrayOrTupleSchema = JSONSchema & Readonly<{
-  type: "array";
-}>;
-type ArraySchema = Omit<JSONSchema, "items"> & Readonly<{
-  type: "array";
-  items: JSONSchema;
-}>;
-type TupleSchema = JSONSchema & Readonly<{
-  type: "array";
-  items: readonly JSONSchema[];
-}>;
-type ParseArrayOrTupleSchema<ARRAY_OR_TUPLE_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ARRAY_OR_TUPLE_SCHEMA extends ArraySchema ? _$Array<ParseSchema<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>> : ARRAY_OR_TUPLE_SCHEMA extends TupleSchema ? $Union<ApplyMinMaxAndAdditionalItems<ParseTupleItems<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>, ARRAY_OR_TUPLE_SCHEMA, OPTIONS>> : _$Array;
-type ParseTupleItems<ITEM_SCHEMAS extends readonly JSONSchema[], OPTIONS extends ParseSchemaOptions> = ITEM_SCHEMAS extends readonly [infer ITEM_SCHEMAS_HEAD, ...infer ITEM_SCHEMAS_TAIL] ? ITEM_SCHEMAS_HEAD extends JSONSchema ? ITEM_SCHEMAS_TAIL extends readonly JSONSchema[] ? [ParseSchema<ITEM_SCHEMAS_HEAD, OPTIONS>, ...ParseTupleItems<ITEM_SCHEMAS_TAIL, OPTIONS>] : never : never : [];
-type ApplyMinMaxAndAdditionalItems<PARSED_ITEM_SCHEMAS extends any[], ROOT_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ApplyAdditionalItems<ApplyMinMax<PARSED_ITEM_SCHEMAS, ROOT_SCHEMA extends Readonly<{
-  minItems: number;
-}> ? ROOT_SCHEMA["minItems"] : 0, ROOT_SCHEMA extends Readonly<{
-  maxItems: number;
-}> ? ROOT_SCHEMA["maxItems"] : undefined>, ROOT_SCHEMA extends Readonly<{
-  additionalItems: JSONSchema;
-}> ? ROOT_SCHEMA["additionalItems"] : true, OPTIONS>;
-type ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS extends any[], MIN extends number, MAX extends number | undefined, RESULT = never, HAS_ENCOUNTERED_MIN extends boolean = false, HAS_ENCOUNTERED_MAX extends boolean = false, INITIAL_PARSED_ITEM_SCHEMAS extends any[] = RECURSED_PARSED_ITEM_SCHEMAS> = And<Not<DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>>, DoesExtend<RECURSED_PARSED_ITEM_SCHEMAS, [any, ...any[]]>> extends true ? RECURSED_PARSED_ITEM_SCHEMAS extends [...infer RECURSED_PARSED_ITEM_SCHEMAS_BODY, unknown] ? ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS_BODY, MIN, MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"] extends MAX ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS>, HAS_ENCOUNTERED_MIN extends true ? true : DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, HAS_ENCOUNTERED_MAX extends true ? true : DoesExtend<MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, INITIAL_PARSED_ITEM_SCHEMAS> : never : {
-  result: MAX extends undefined ? RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : HAS_ENCOUNTERED_MAX extends true ? RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX> extends true ? never : RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS>;
-  hasEncounteredMin: DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>;
-  hasEncounteredMax: HAS_ENCOUNTERED_MAX extends true ? true : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? true : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX>;
-  completeTuple: INITIAL_PARSED_ITEM_SCHEMAS;
-};
-type IsLongerThan<TUPLE extends any[], LENGTH extends number | undefined, RESULT extends boolean = false> = LENGTH extends undefined ? false : TUPLE["length"] extends LENGTH ? true : TUPLE extends [any, ...infer TUPLE_TAIL] ? IsLongerThan<TUPLE_TAIL, LENGTH> : RESULT;
-type ApplyAdditionalItems<APPLY_MIN_MAX_RESULT extends {
-  result: any;
-  hasEncounteredMin: boolean;
-  hasEncounteredMax: boolean;
-  completeTuple: any[];
-}, ADDITIONAL_ITEMS_SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions> = APPLY_MIN_MAX_RESULT extends {
-  hasEncounteredMax: true;
-} ? APPLY_MIN_MAX_RESULT extends {
-  hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] : Never : ADDITIONAL_ITEMS_SCHEMA extends false ? APPLY_MIN_MAX_RESULT extends {
-  hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] : Never : ADDITIONAL_ITEMS_SCHEMA extends true ? APPLY_MIN_MAX_RESULT extends {
-  hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : APPLY_MIN_MAX_RESULT extends {
-  hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>>;
-//#endregion
-export { ArrayOrTupleSchema, ParseArrayOrTupleSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.mts

@@ -1,14 +0,0 @@
-import { Const } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/const.mjs";
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { Writable } from "../type-utils/writable.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.ts
-type ConstSchema = JSONSchema & Readonly<{
-  const: unknown;
-}>;
-type ParseConstSchema<CONST_SCHEMA extends ConstSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseConst<CONST_SCHEMA>, ParseSchema<Omit<CONST_SCHEMA, "const">, OPTIONS>>;
-type ParseConst<CONST_SCHEMA extends ConstSchema> = Const<Writable<CONST_SCHEMA["const"]>>;
-//#endregion
-export { ConstSchema, ParseConstSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.mts

@@ -1,13 +0,0 @@
-import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { DeserializationPattern } from "../definitions/deserializationPattern.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.ts
-type DeserializeSchema<SCHEMA extends JSONSchema, OPTIONS extends Omit<ParseSchemaOptions, "deserialize"> & {
-  deserialize: DeserializationPattern[];
-}> = RecurseOnDeserializationPatterns<SCHEMA, OPTIONS["deserialize"]>;
-type RecurseOnDeserializationPatterns<SCHEMA extends JSONSchema, DESERIALIZATION_PATTERNS extends DeserializationPattern[], RESULT = Any> = DESERIALIZATION_PATTERNS extends [infer DESERIALIZATION_PATTERNS_HEAD, ...infer DESERIALIZATION_PATTERNS_TAIL] ? DESERIALIZATION_PATTERNS_HEAD extends DeserializationPattern ? DESERIALIZATION_PATTERNS_TAIL extends DeserializationPattern[] ? RecurseOnDeserializationPatterns<SCHEMA, DESERIALIZATION_PATTERNS_TAIL, SCHEMA extends DESERIALIZATION_PATTERNS_HEAD["pattern"] ? $Intersect<Any<true, DESERIALIZATION_PATTERNS_HEAD["output"]>, RESULT> : RESULT> : never : never : RESULT;
-//#endregion
-export { DeserializeSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.mts

@@ -1,14 +0,0 @@
-import { Enum } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/enum.mjs";
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { Writable } from "../type-utils/writable.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.ts
-type EnumSchema = JSONSchema & Readonly<{
-  enum: readonly unknown[];
-}>;
-type ParseEnumSchema<ENUM_SCHEMA extends EnumSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseEnum<ENUM_SCHEMA>, ParseSchema<Omit<ENUM_SCHEMA, "enum">, OPTIONS>>;
-type ParseEnum<ENUM_SCHEMA extends EnumSchema> = Enum<Writable<ENUM_SCHEMA["enum"][number]>>;
-//#endregion
-export { EnumSchema, ParseEnumSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.mts

@@ -1,20 +0,0 @@
-import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
-import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
-import { _$Exclude } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/exclusion/index.mjs";
-import { JSONSchema } from "../definitions/jsonSchema.mjs";
-import { MergeSubSchema } from "./utils.mjs";
-import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
-
-//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.ts
-type IfThenElseSchema = JSONSchema & {
-  if: JSONSchema;
-  then?: JSONSchema;
-  else?: JSONSchema;
-};
-type ParseIfThenElseSchema<IF_THEN_ELSE_SCHEMA extends IfThenElseSchema, OPTIONS extends ParseSchemaOptions, REST_SCHEMA extends JSONSchema = Omit<IF_THEN_ELSE_SCHEMA, "if" | "then" | "else">, IF_SCHEMA extends JSONSchema = MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["if"]>, PARSED_THEN_SCHEMA = (IF_THEN_ELSE_SCHEMA extends {
-  then: JSONSchema;
-} ? $Intersect<ParseSchema<IF_SCHEMA, OPTIONS>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["then"]>, OPTIONS>> : ParseSchema<IF_SCHEMA, OPTIONS>), PARSED_ELSE_SCHEMA = (IF_THEN_ELSE_SCHEMA extends {
-  else: JSONSchema;
-} ? $Intersect<_$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["else"]>, OPTIONS>> : _$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>)> = $Intersect<$Union<PARSED_THEN_SCHEMA | PARSED_ELSE_SCHEMA>, ParseSchema<REST_SCHEMA, OPTIONS>>;
-//#endregion
-export { IfThenElseSchema, ParseIfThenElseSchema };