@lobehub/ui 5.64.2 → 6.0.0-beta.10

package/es/node_modules/.pnpm/@eslint_plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/index.d.mts

@@ -0,0 +1,7 @@
+import { RuleVisitor as RuleVisitor$1 } from "../../../../../../@eslint_core@1.2.1/node_modules/@eslint/core/dist/esm/types.mjs";
+import { CustomRuleVisitorWithExit as CustomRuleVisitorWithExit$1 } from "./types.mjs";
+//#region node_modules/.pnpm/@eslint+plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/index.d.cts
+export type RuleVisitor = RuleVisitor$1;
+export type CustomRuleVisitorWithExit<RuleVisitorType extends RuleVisitor> = CustomRuleVisitorWithExit$1<RuleVisitorType>;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/es/node_modules/.pnpm/@eslint_plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/types.d.mts

@@ -0,0 +1,8 @@
+import { RuleVisitor } from "../../../../../../@eslint_core@1.2.1/node_modules/@eslint/core/dist/esm/types.mjs";
+//#region node_modules/.pnpm/@eslint+plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/types.d.cts
+/**
+ * Adds matching `:exit` selector properties for each key of a `RuleVisitor`.
+ */
+export type CustomRuleVisitorWithExit<RuleVisitorType extends RuleVisitor> = { [Key in keyof RuleVisitorType as Key | `${Key & string}:exit`]: RuleVisitorType[Key]; };
+//#endregion
+//# sourceMappingURL=types.d.mts.map

package/es/node_modules/.pnpm/@types_estree@1.0.9/node_modules/@types/estree/index.d.mts

@@ -16,7 +16,7 @@
 // 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 {
+export 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"`
@@ -24,11 +24,11 @@ interface BaseNodeWithoutComments {
   loc?: SourceLocation | null | undefined;
   range?: [number, number] | undefined;
 }
-interface BaseNode extends BaseNodeWithoutComments {
+export interface BaseNode extends BaseNodeWithoutComments {
   leadingComments?: Comment[] | undefined;
   trailingComments?: Comment[] | undefined;
 }
-interface NodeMap {
+export interface NodeMap {
   AssignmentProperty: AssignmentProperty;
   CatchClause: CatchClause;
   Class: Class;
@@ -52,34 +52,34 @@ interface NodeMap {
   TemplateElement: TemplateElement;
   VariableDeclarator: VariableDeclarator;
 }
-type Node = NodeMap[keyof NodeMap];
-interface Comment extends BaseNodeWithoutComments {
+export type Node = NodeMap[keyof NodeMap];
+export interface Comment extends BaseNodeWithoutComments {
   type: "Line" | "Block";
   value: string;
 }
-interface SourceLocation {
+export interface SourceLocation {
   source?: string | null | undefined;
   start: Position;
   end: Position;
 }
-interface Position {
+export interface Position {
   /** >= 1 */
   line: number;
   /** >= 0 */
   column: number;
 }
-interface Program extends BaseNode {
+export interface Program extends BaseNode {
   type: "Program";
   sourceType: "script" | "module";
   body: Array<Directive | Statement | ModuleDeclaration>;
   comments?: Comment[] | undefined;
 }
-interface Directive extends BaseNode {
+export interface Directive extends BaseNode {
   type: "ExpressionStatement";
   expression: Literal;
   directive: string;
 }
-interface BaseFunction extends BaseNode {
+export interface BaseFunction extends BaseNode {
   params: Pattern[];
   generator?: boolean | undefined;
   async?: boolean | undefined;
@@ -88,117 +88,117 @@ interface BaseFunction extends BaseNode {
   // FunctionExpressions have only BlockStatement bodies.
   body: BlockStatement | Expression;
 }
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-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 {
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+export type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+export interface BaseStatement extends BaseNode {}
+export interface EmptyStatement extends BaseStatement {
   type: "EmptyStatement";
 }
-interface BlockStatement extends BaseStatement {
+export interface BlockStatement extends BaseStatement {
   type: "BlockStatement";
   body: Statement[];
   innerComments?: Comment[] | undefined;
 }
-interface StaticBlock extends Omit<BlockStatement, "type"> {
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
   type: "StaticBlock";
 }
-interface ExpressionStatement extends BaseStatement {
+export interface ExpressionStatement extends BaseStatement {
   type: "ExpressionStatement";
   expression: Expression;
 }
-interface IfStatement extends BaseStatement {
+export interface IfStatement extends BaseStatement {
   type: "IfStatement";
   test: Expression;
   consequent: Statement;
   alternate?: Statement | null | undefined;
 }
-interface LabeledStatement extends BaseStatement {
+export interface LabeledStatement extends BaseStatement {
   type: "LabeledStatement";
   label: Identifier;
   body: Statement;
 }
-interface BreakStatement extends BaseStatement {
+export interface BreakStatement extends BaseStatement {
   type: "BreakStatement";
   label?: Identifier | null | undefined;
 }
-interface ContinueStatement extends BaseStatement {
+export interface ContinueStatement extends BaseStatement {
   type: "ContinueStatement";
   label?: Identifier | null | undefined;
 }
-interface WithStatement extends BaseStatement {
+export interface WithStatement extends BaseStatement {
   type: "WithStatement";
   object: Expression;
   body: Statement;
 }
-interface SwitchStatement extends BaseStatement {
+export interface SwitchStatement extends BaseStatement {
   type: "SwitchStatement";
   discriminant: Expression;
   cases: SwitchCase[];
 }
-interface ReturnStatement extends BaseStatement {
+export interface ReturnStatement extends BaseStatement {
   type: "ReturnStatement";
   argument?: Expression | null | undefined;
 }
-interface ThrowStatement extends BaseStatement {
+export interface ThrowStatement extends BaseStatement {
   type: "ThrowStatement";
   argument: Expression;
 }
-interface TryStatement extends BaseStatement {
+export interface TryStatement extends BaseStatement {
   type: "TryStatement";
   block: BlockStatement;
   handler?: CatchClause | null | undefined;
   finalizer?: BlockStatement | null | undefined;
 }
-interface WhileStatement extends BaseStatement {
+export interface WhileStatement extends BaseStatement {
   type: "WhileStatement";
   test: Expression;
   body: Statement;
 }
-interface DoWhileStatement extends BaseStatement {
+export interface DoWhileStatement extends BaseStatement {
   type: "DoWhileStatement";
   body: Statement;
   test: Expression;
 }
-interface ForStatement extends BaseStatement {
+export 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 {
+export interface BaseForXStatement extends BaseStatement {
   left: VariableDeclaration | Pattern;
   right: Expression;
   body: Statement;
 }
-interface ForInStatement extends BaseForXStatement {
+export interface ForInStatement extends BaseForXStatement {
   type: "ForInStatement";
 }
-interface DebuggerStatement extends BaseStatement {
+export interface DebuggerStatement extends BaseStatement {
   type: "DebuggerStatement";
 }
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+export interface BaseDeclaration extends BaseStatement {}
+export 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 {
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
   id: Identifier;
 }
-interface VariableDeclaration extends BaseDeclaration {
+export interface VariableDeclaration extends BaseDeclaration {
   type: "VariableDeclaration";
   declarations: VariableDeclarator[];
   kind: "var" | "let" | "const" | "using" | "await using";
 }
-interface VariableDeclarator extends BaseNode {
+export interface VariableDeclarator extends BaseNode {
   type: "VariableDeclarator";
   id: Pattern;
   init?: Expression | null | undefined;
 }
-interface ExpressionMap {
+export interface ExpressionMap {
   ArrayExpression: ArrayExpression;
   ArrowFunctionExpression: ArrowFunctionExpression;
   AssignmentExpression: AssignmentExpression;
@@ -225,29 +225,29 @@ interface ExpressionMap {
   UpdateExpression: UpdateExpression;
   YieldExpression: YieldExpression;
 }
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
+export type Expression = ExpressionMap[keyof ExpressionMap];
+export interface BaseExpression extends BaseNode {}
+export type ChainElement = SimpleCallExpression | MemberExpression;
+export interface ChainExpression extends BaseExpression {
   type: "ChainExpression";
   expression: ChainElement;
 }
-interface ThisExpression extends BaseExpression {
+export interface ThisExpression extends BaseExpression {
   type: "ThisExpression";
 }
-interface ArrayExpression extends BaseExpression {
+export interface ArrayExpression extends BaseExpression {
   type: "ArrayExpression";
   elements: Array<Expression | SpreadElement | null>;
 }
-interface ObjectExpression extends BaseExpression {
+export interface ObjectExpression extends BaseExpression {
   type: "ObjectExpression";
   properties: Array<Property | SpreadElement>;
 }
-interface PrivateIdentifier extends BaseNode {
+export interface PrivateIdentifier extends BaseNode {
   type: "PrivateIdentifier";
   name: string;
 }
-interface Property extends BaseNode {
+export interface Property extends BaseNode {
   type: "Property";
   key: Expression;
   value: Expression | Pattern; // Could be an AssignmentProperty
@@ -256,100 +256,100 @@ interface Property extends BaseNode {
   shorthand: boolean;
   computed: boolean;
 }
-interface PropertyDefinition extends BaseNode {
+export interface PropertyDefinition extends BaseNode {
   type: "PropertyDefinition";
   key: Expression | PrivateIdentifier;
   value?: Expression | null | undefined;
   computed: boolean;
   static: boolean;
 }
-interface FunctionExpression extends BaseFunction, BaseExpression {
+export interface FunctionExpression extends BaseFunction, BaseExpression {
   id?: Identifier | null | undefined;
   type: "FunctionExpression";
   body: BlockStatement;
 }
-interface SequenceExpression extends BaseExpression {
+export interface SequenceExpression extends BaseExpression {
   type: "SequenceExpression";
   expressions: Expression[];
 }
-interface UnaryExpression extends BaseExpression {
+export interface UnaryExpression extends BaseExpression {
   type: "UnaryExpression";
   operator: UnaryOperator;
   prefix: true;
   argument: Expression;
 }
-interface BinaryExpression extends BaseExpression {
+export interface BinaryExpression extends BaseExpression {
   type: "BinaryExpression";
   operator: BinaryOperator;
   left: Expression | PrivateIdentifier;
   right: Expression;
 }
-interface AssignmentExpression extends BaseExpression {
+export interface AssignmentExpression extends BaseExpression {
   type: "AssignmentExpression";
   operator: AssignmentOperator;
   left: Pattern | MemberExpression;
   right: Expression;
 }
-interface UpdateExpression extends BaseExpression {
+export interface UpdateExpression extends BaseExpression {
   type: "UpdateExpression";
   operator: UpdateOperator;
   argument: Expression;
   prefix: boolean;
 }
-interface LogicalExpression extends BaseExpression {
+export interface LogicalExpression extends BaseExpression {
   type: "LogicalExpression";
   operator: LogicalOperator;
   left: Expression;
   right: Expression;
 }
-interface ConditionalExpression extends BaseExpression {
+export interface ConditionalExpression extends BaseExpression {
   type: "ConditionalExpression";
   test: Expression;
   alternate: Expression;
   consequent: Expression;
 }
-interface BaseCallExpression extends BaseExpression {
+export interface BaseCallExpression extends BaseExpression {
   callee: Expression | Super;
   arguments: Array<Expression | SpreadElement>;
 }
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
+export type CallExpression = SimpleCallExpression | NewExpression;
+export interface SimpleCallExpression extends BaseCallExpression {
   type: "CallExpression";
   optional: boolean;
 }
-interface NewExpression extends BaseCallExpression {
+export interface NewExpression extends BaseCallExpression {
   type: "NewExpression";
 }
-interface MemberExpression extends BaseExpression, BasePattern {
+export 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 {
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+export interface BasePattern extends BaseNode {}
+export interface SwitchCase extends BaseNode {
   type: "SwitchCase";
   test?: Expression | null | undefined;
   consequent: Statement[];
 }
-interface CatchClause extends BaseNode {
+export interface CatchClause extends BaseNode {
   type: "CatchClause";
   param: Pattern | null;
   body: BlockStatement;
 }
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
   type: "Identifier";
   name: string;
 }
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+export interface SimpleLiteral extends BaseNode, BaseExpression {
   type: "Literal";
   value: string | boolean | number | null;
   raw?: string | undefined;
 }
-interface RegExpLiteral extends BaseNode, BaseExpression {
+export interface RegExpLiteral extends BaseNode, BaseExpression {
   type: "Literal";
   value?: RegExp | null | undefined;
   regex: {
@@ -358,49 +358,49 @@ interface RegExpLiteral extends BaseNode, BaseExpression {
   };
   raw?: string | undefined;
 }
-interface BigIntLiteral extends BaseNode, BaseExpression {
+export 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 {
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+export type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+export type LogicalOperator = "||" | "&&" | "??";
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+export type UpdateOperator = "++" | "--";
+export interface ForOfStatement extends BaseForXStatement {
   type: "ForOfStatement";
   await: boolean;
 }
-interface Super extends BaseNode {
+export interface Super extends BaseNode {
   type: "Super";
 }
-interface SpreadElement extends BaseNode {
+export interface SpreadElement extends BaseNode {
   type: "SpreadElement";
   argument: Expression;
 }
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
   type: "ArrowFunctionExpression";
   expression: boolean;
   body: BlockStatement | Expression;
 }
-interface YieldExpression extends BaseExpression {
+export interface YieldExpression extends BaseExpression {
   type: "YieldExpression";
   argument?: Expression | null | undefined;
   delegate: boolean;
 }
-interface TemplateLiteral extends BaseExpression {
+export interface TemplateLiteral extends BaseExpression {
   type: "TemplateLiteral";
   quasis: TemplateElement[];
   expressions: Expression[];
 }
-interface TaggedTemplateExpression extends BaseExpression {
+export interface TaggedTemplateExpression extends BaseExpression {
   type: "TaggedTemplateExpression";
   tag: Expression;
   quasi: TemplateLiteral;
 }
-interface TemplateElement extends BaseNode {
+export interface TemplateElement extends BaseNode {
   type: "TemplateElement";
   tail: boolean;
   value: {
@@ -409,38 +409,38 @@ interface TemplateElement extends BaseNode {
     raw: string;
   };
 }
-interface AssignmentProperty extends Property {
+export interface AssignmentProperty extends Property {
   value: Pattern;
   kind: "init";
   method: boolean; // false
 }
-interface ObjectPattern extends BasePattern {
+export interface ObjectPattern extends BasePattern {
   type: "ObjectPattern";
   properties: Array<AssignmentProperty | RestElement>;
 }
-interface ArrayPattern extends BasePattern {
+export interface ArrayPattern extends BasePattern {
   type: "ArrayPattern";
   elements: Array<Pattern | null>;
 }
-interface RestElement extends BasePattern {
+export interface RestElement extends BasePattern {
   type: "RestElement";
   argument: Pattern;
 }
-interface AssignmentPattern extends BasePattern {
+export interface AssignmentPattern extends BasePattern {
   type: "AssignmentPattern";
   left: Pattern;
   right: Expression;
 }
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
+export type Class = ClassDeclaration | ClassExpression;
+export interface BaseClass extends BaseNode {
   superClass?: Expression | null | undefined;
   body: ClassBody;
 }
-interface ClassBody extends BaseNode {
+export interface ClassBody extends BaseNode {
   type: "ClassBody";
   body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
 }
-interface MethodDefinition extends BaseNode {
+export interface MethodDefinition extends BaseNode {
   type: "MethodDefinition";
   key: Expression | PrivateIdentifier;
   value: FunctionExpression;
@@ -448,81 +448,80 @@ interface MethodDefinition extends BaseNode {
   computed: boolean;
   static: boolean;
 }
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+export 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 {
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
   id: Identifier;
 }
-interface ClassExpression extends BaseClass, BaseExpression {
+export interface ClassExpression extends BaseClass, BaseExpression {
   type: "ClassExpression";
   id?: Identifier | null | undefined;
 }
-interface MetaProperty extends BaseExpression {
+export interface MetaProperty extends BaseExpression {
   type: "MetaProperty";
   meta: Identifier;
   property: Identifier;
 }
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
+export type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
   local: Identifier;
 }
-interface ImportDeclaration extends BaseModuleDeclaration {
+export interface ImportDeclaration extends BaseModuleDeclaration {
   type: "ImportDeclaration";
   specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
   attributes: ImportAttribute[];
   source: Literal;
 }
-interface ImportSpecifier extends BaseModuleSpecifier {
+export interface ImportSpecifier extends BaseModuleSpecifier {
   type: "ImportSpecifier";
   imported: Identifier | Literal;
 }
-interface ImportAttribute extends BaseNode {
+export interface ImportAttribute extends BaseNode {
   type: "ImportAttribute";
   key: Identifier | Literal;
   value: Literal;
 }
-interface ImportExpression extends BaseExpression {
+export interface ImportExpression extends BaseExpression {
   type: "ImportExpression";
   source: Expression;
   options?: Expression | null | undefined;
 }
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
   type: "ImportDefaultSpecifier";
 }
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
   type: "ImportNamespaceSpecifier";
 }
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
   type: "ExportNamedDeclaration";
   declaration?: Declaration | null | undefined;
   specifiers: ExportSpecifier[];
   attributes: ImportAttribute[];
   source?: Literal | null | undefined;
 }
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
   type: "ExportSpecifier";
   local: Identifier | Literal;
   exported: Identifier | Literal;
 }
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
   type: "ExportDefaultDeclaration";
   declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
 }
-interface ExportAllDeclaration extends BaseModuleDeclaration {
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
   type: "ExportAllDeclaration";
   exported: Identifier | Literal | null;
   attributes: ImportAttribute[];
   source: Literal;
 }
-interface AwaitExpression extends BaseExpression {
+export interface AwaitExpression extends BaseExpression {
   type: "AwaitExpression";
   argument: Expression;
 }
 //#endregion
-export { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentOperator, AssignmentPattern, AssignmentProperty, AwaitExpression, BaseCallExpression, BaseClass, BaseDeclaration, BaseExpression, BaseForXStatement, BaseFunction, BaseModuleDeclaration, BaseModuleSpecifier, BaseNode, BaseNodeWithoutComments, BasePattern, BaseStatement, BigIntLiteral, BinaryExpression, BinaryOperator, BlockStatement, BreakStatement, CallExpression, CatchClause, ChainElement, ChainExpression, Class, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, Declaration, Directive, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, Expression, ExpressionMap, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, Function, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, Literal, LogicalExpression, LogicalOperator, MaybeNamedClassDeclaration, MaybeNamedFunctionDeclaration, MemberExpression, MetaProperty, MethodDefinition, ModuleDeclaration, ModuleSpecifier, NewExpression, Node, NodeMap, ObjectExpression, ObjectPattern, Pattern, Position, PrivateIdentifier, Program, Property, PropertyDefinition, RegExpLiteral, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SimpleLiteral, SourceLocation, SpreadElement, Statement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UnaryOperator, UpdateExpression, UpdateOperator, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression };
 //# sourceMappingURL=index.d.mts.map

package/es/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.mts

@@ -5,20 +5,20 @@
 /**
  * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
  */
-type JSONSchema4TypeName = "string" //
+export type JSONSchema4TypeName = "string" //
  | "number" | "integer" | "boolean" | "object" | "array" | "null" | "any";
 /**
  * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
  */
-type JSONSchema4Type = string //
+export type JSONSchema4Type = string //
  | number | boolean | JSONSchema4Object | JSONSchema4Array | null;
 // Workaround for infinite type recursion
-interface JSONSchema4Object {
+export interface JSONSchema4Object {
   [key: string]: JSONSchema4Type;
 }
 // Workaround for infinite type recursion
 // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
-interface JSONSchema4Array extends Array<JSONSchema4Type> {}
+export interface JSONSchema4Array extends Array<JSONSchema4Type> {}
 /**
  * Meta schema
  *
@@ -32,12 +32,12 @@ interface JSONSchema4Array extends Array<JSONSchema4Type> {}
  *
  * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
  */
-type JSONSchema4Version = string;
+export type JSONSchema4Version = string;
 /**
  * JSON Schema V4
  * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
  */
-interface JSONSchema4 {
+export interface JSONSchema4 {
   id?: string | undefined;
   $ref?: string | undefined;
   $schema?: JSONSchema4Version | undefined;
@@ -197,5 +197,4 @@ interface JSONSchema4 {
   format?: string | undefined;
 }
 //#endregion
-export { JSONSchema4, JSONSchema4Array, JSONSchema4Object, JSONSchema4Type, JSONSchema4TypeName, JSONSchema4Version };
 //# sourceMappingURL=index.d.mts.map