@kubb/core 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/{FileManager-DSLZ6ps7.d.cts → FileManager-CpuFz6eH.d.ts}

@@ -1,19 +1,8 @@
-import PQueue from 'p-queue';
 import { write, read } from '@kubb/fs';
 import * as KubbFile from '@kubb/fs/types';
-import { BaseName, File, UUID } from '@kubb/fs/src/types.ts';
+import { ResolvedFile } from '@kubb/fs/types';
 import { PossiblePromise, GreaterThan } from '@kubb/types';
-import { DirectoryTreeOptions } from 'directory-tree';
-import { E as EventEmitter, L as Logger } from './logger-DChjnJMn.cjs';
-
-type BarrelManagerOptions = {
-    treeNode?: DirectoryTreeOptions;
-    isTypeOnly?: boolean;
-    /**
-     * Add .ts or .js
-     */
-    extName?: KubbFile.Extname;
-};
+import { E as EventEmitter, L as Logger } from './logger-DvbHXjIO.js';
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 /**
@@ -23,6 +12,7 @@ type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    message: string;
     strategy: Strategy;
     hookName: H;
     plugin: Plugin;
@@ -34,15 +24,11 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
     result: Result;
     plugin: Plugin;
 };
-type Options$1 = {
+type Options = {
     logger: Logger;
-    /**
-     * Task for the FileManager
-     */
-    task: (file: ResolvedFile) => Promise<ResolvedFile>;
 };
 type Events = {
-    execute: [executer: Executer];
+    executing: [executer: Executer];
     executed: [executer: Executer];
     error: [error: Error];
 };
@@ -61,8 +47,8 @@ declare class PluginManager {
     readonly config: Config;
     readonly executed: Array<Executer>;
     readonly logger: Logger;
-    readonly queue: PQueue;
-    constructor(config: Config, options: Options$1);
+    readonly options: Options;
+    constructor(config: Config, options: Options);
     getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{
         pluginKey: Plugin['key'];
     }>;
@@ -75,60 +61,67 @@ declare class PluginManager {
     /**
      * Run a specific hookName for plugin x.
      */
-    hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+    hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, message, }: {
         pluginKey: Plugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
-    }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
+        message: string;
+    }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
     /**
      * Run a specific hookName for plugin x.
      */
-    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, message, }: {
         pluginKey: Plugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
+        message: string;
     }): Array<ReturnType<ParseResult<H>>> | null;
     /**
      * First non-null result stops and will return it's value.
      */
-    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, message, }: {
         hookName: H;
         parameters: PluginParameter<H>;
         skipped?: ReadonlySet<Plugin> | null;
+        message: string;
     }): Promise<SafeParseResult<H>>;
     /**
      * First non-null result stops and will return it's value.
      */
-    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, message, }: {
         hookName: H;
         parameters: PluginParameter<H>;
         skipped?: ReadonlySet<Plugin> | null;
+        message: string;
     }): SafeParseResult<H>;
     /**
      * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
      */
-    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
+    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, message, }: {
         hookName: H;
         parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+        message: string;
     }): Promise<Awaited<TOuput>[]>;
     /**
      * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
      */
-    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
+    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, message, }: {
         hookName: H;
         parameters: PluginParameter<H>;
         reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>;
+        message: string;
     }): Promise<Argument0<H>>;
     /**
      * Chains plugins
      */
-    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
+    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters, message, }: {
         hookName: H;
         parameters?: PluginParameter<H>;
+        message: string;
     }): Promise<void>;
     getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: Plugin['key']): Plugin[];
     static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>]>(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput;
-    static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+    static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "buildEnd"];
 }
 
 interface Cache<TStore extends object = object> {
@@ -154,11 +147,9 @@ type UserConfig = Omit<Config, 'root' | 'plugins'> & {
      */
     root?: string;
     /**
-     * Plugin type can be KubbJSONPlugin or Plugin
-     * Example: ['@kubb/plugin-oas', { output: false }]
-     * Or: pluginOas({ output: false })
+     * Plugin type should be a Kubb plugin
      */
-    plugins?: Array<Omit<UnknownUserPlugin, 'api'>>;
+    plugins?: Array<Omit<UnknownUserPlugin, 'context'>>;
 };
 type InputPath = {
     /**
@@ -204,6 +195,11 @@ type Config<TInput = Input> = {
          * @default true
          */
         write?: boolean;
+        /**
+         * Define what needs to exported, here you can also disable the export of barrel files
+         * @default `'barrelNamed'`
+         */
+        exportType?: 'barrel' | 'barrelNamed' | false;
     };
     /**
      * Array of Kubb plugins to use.
@@ -236,9 +232,9 @@ TOptions extends object = object,
  */
 TResolvedOptions extends object = TOptions, 
 /**
- * API that you want to expose to other plugins.
+ * Context that you want to expose to other plugins.
  */
-TAPI = any, 
+TContext = any, 
 /**
  * When calling `resolvePath` you can specify better types.
  */
@@ -250,7 +246,7 @@ TResolvePathOptions extends object = object> = {
     key: PluginKey<TName | string>;
     options: TOptions;
     resolvedOptions: TResolvedOptions;
-    api: TAPI;
+    context: TContext;
     resolvePathOptions: TResolvePathOptions;
 };
 type PluginKey<TName> = [name: TName, identifier?: string | number];
@@ -268,17 +264,17 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
     options: TOptions['resolvedOptions'];
     /**
      * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-     * Can be used to validate depended plugins.
+     * Can be used to validate dependent plugins.
      */
     pre?: Array<string>;
     /**
      * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
      */
     post?: Array<string>;
-} & (TOptions['api'] extends never ? {
-    api?: never;
+} & (TOptions['context'] extends never ? {
+    context?: never;
 } : {
-    api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api'];
+    context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
 });
 type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
 type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>;
@@ -293,9 +289,24 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
      * @private
      */
     key: TOptions['key'];
+    output?: {
+        /**
+         * Output to save the clients.
+         */
+        path: string;
+        /**
+         * Add an extension to the generated imports and exports, default it will not use an extension
+         */
+        extName?: KubbFile.Extname;
+        /**
+         * Define what needs to exported, here you can also disable the export of barrel files
+         * @default `'barrelNamed'`
+         */
+        exportType?: 'barrel' | 'barrelNamed' | false;
+    };
     /**
      * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-     * Can be used to validate depended plugins.
+     * Can be used to validate dependent plugins.
      */
     pre?: Array<string>;
     /**
@@ -306,10 +317,10 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
     options: TOptions['resolvedOptions'];
-} & (TOptions['api'] extends never ? {
-    api?: never;
+} & (TOptions['context'] extends never ? {
+    context?: never;
 } : {
-    api: TOptions['api'];
+    context: TOptions['context'];
 });
 type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
 type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
@@ -332,21 +343,6 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * @example ('pet') => 'Pet'
      */
     resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
-    /**
-     * Makes it possible to run async logic to override the path defined previously by `resolvePath`.
-     * @type hookFirst
-     */
-    load?: (this: Omit<PluginContext<TOptions>, 'addFile'>, path: KubbFile.Path) => PossiblePromise<TransformResult | null>;
-    /**
-     * Transform the source-code.
-     * @type hookReduceArg0
-     */
-    transform?: (this: Omit<PluginContext<TOptions>, 'addFile'>, source: string, path: KubbFile.Path) => PossiblePromise<TransformResult>;
-    /**
-     * Write the result to the file-system based on the id(defined by `resolvePath` or changed by `load`).
-     * @type hookParallel
-     */
-    writeFile?: (this: Omit<PluginContext<TOptions>, 'addFile'>, path: KubbFile.Path, source: string | undefined) => PossiblePromise<string | void>;
     /**
      * End of the plugin lifecycle.
      * @type hookParallel
@@ -380,7 +376,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
     cache: Cache<PluginCache>;
     fileManager: FileManager;
     pluginManager: PluginManager;
-    addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.File>>;
+    addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>;
     resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     logger: Logger;
@@ -393,63 +389,81 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
      */
     plugin: Plugin<TOptions>;
 };
-type TransformResult = string | null;
 
-type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = File<TMeta, TBaseName> & {
+type BarrelData = {
+    file?: KubbFile.File;
     /**
-     * @default crypto.randomUUID()
-     */
-    id: UUID;
-    /**
-     * Contains the first part of the baseName, generated based on baseName
-     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     * @deprecated use file instead
      */
+    type: KubbFile.Mode;
+    path: string;
     name: string;
 };
+declare class TreeNode {
+    #private;
+    data: BarrelData;
+    parent?: TreeNode;
+    children: Array<TreeNode>;
+    constructor(data: BarrelData, parent?: TreeNode);
+    addChild(data: BarrelData): TreeNode;
+    get root(): TreeNode;
+    get leaves(): Array<TreeNode>;
+    forEach(callback: (treeNode: TreeNode) => void): this;
+    findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined;
+    forEachDeep(callback: (treeNode: TreeNode) => void): void;
+    filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode>;
+    mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T>;
+    static build(files: KubbFile.File[], root?: string): TreeNode | null;
+}
+type DirectoryTree = {
+    name: string;
+    path: string;
+    file?: KubbFile.File;
+    children: Array<DirectoryTree>;
+};
+
 type FileMetaBase = {
     pluginKey?: Plugin['key'];
 };
-type FileWithMeta<TMeta extends FileMetaBase = FileMetaBase> = KubbFile.File<TMeta>;
-type AddResult<T extends Array<FileWithMeta>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>;
+type AddResult<T extends Array<KubbFile.File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>;
 type AddIndexesProps = {
     /**
      * Root based on root and output.path specified in the config
      */
     root: string;
+    files: KubbFile.File[];
     /**
      * Output for plugin
      */
     output: {
         path: string;
-        exportAs?: string;
         extName?: KubbFile.Extname;
+        exportAs?: string;
         exportType?: 'barrel' | 'barrelNamed' | false;
     };
-    logger: Logger;
-    options?: BarrelManagerOptions;
-    meta?: FileWithMeta['meta'];
-};
-type Options = {
-    queue?: PQueue;
-    task?: (file: ResolvedFile) => Promise<ResolvedFile>;
+    group?: {
+        output: string;
+        exportAs: string;
+    };
+    logger?: Logger;
+    meta?: FileMetaBase;
 };
 declare class FileManager {
     #private;
-    constructor({ task, queue }?: Options);
-    get files(): Array<FileWithMeta>;
-    get isExecuting(): boolean;
-    add<T extends Array<FileWithMeta> = Array<FileWithMeta>>(...files: T): AddResult<T>;
-    addIndexes({ root, output, meta, logger, options }: AddIndexesProps): Promise<void>;
-    getCacheByUUID(UUID: KubbFile.UUID): FileWithMeta | undefined;
-    get(path: KubbFile.Path): Array<FileWithMeta> | undefined;
-    remove(path: KubbFile.Path): void;
-    write(...params: Parameters<typeof write>): Promise<string | undefined>;
-    read(...params: Parameters<typeof read>): Promise<string>;
-    static getSource<TMeta extends FileMetaBase = FileMetaBase>(file: FileWithMeta<TMeta>): Promise<string>;
-    static combineFiles<TMeta extends FileMetaBase = FileMetaBase>(files: Array<FileWithMeta<TMeta> | null>): Array<FileWithMeta<TMeta>>;
+    constructor();
+    get files(): Array<KubbFile.ResolvedFile>;
+    get orderedFiles(): Array<KubbFile.ResolvedFile>;
+    get groupedFiles(): DirectoryTree | null;
+    get treeNode(): TreeNode | null;
+    add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T>;
+    clear(): void;
+    getCacheById(id: string): KubbFile.File | undefined;
+    getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined;
+    deleteByPath(path: KubbFile.Path): void;
+    getBarrelFiles({ files, meta, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]>;
+    write(...params: Parameters<typeof write>): ReturnType<typeof write>;
+    read(...params: Parameters<typeof read>): ReturnType<typeof read>;
     static getMode(path: string | undefined | null): KubbFile.Mode;
-    static get extensions(): Array<KubbFile.Extname>;
-    static isJavascript(baseName: string): boolean;
 }
 
-export { type Config as C, FileManager as F, type GetPluginFactoryOptions as G, type InputPath as I, type PluginContext as P, type ResolvePathParams as R, type TransformResult as T, type UserConfig as U, PluginManager as a, type PluginFactoryOptions as b, type UserPluginWithLifeCycle as c, type FileMetaBase as d, type InputData as e, type PluginKey as f, type UserPlugin as g, type Plugin as h, type PluginWithLifeCycle as i, type PluginLifecycle as j, type PluginLifecycleHooks as k, type PluginParameter as l, type PluginCache as m, type ResolveNameParams as n };
+export { type Config as C, FileManager as F, type GetPluginFactoryOptions as G, type InputPath as I, type PluginContext as P, type ResolvePathParams as R, type UserConfig as U, PluginManager as a, type PluginFactoryOptions as b, type UserPluginWithLifeCycle as c, type FileMetaBase as d, type InputData as e, type PluginKey as f, type UserPlugin as g, type Plugin as h, type PluginWithLifeCycle as i, type PluginLifecycle as j, type PluginLifecycleHooks as k, type PluginParameter as l, type PluginCache as m, type ResolveNameParams as n };

package/dist/chunk-2EU7DMPM.js

@@ -0,0 +1,97 @@
+// src/transformers/transformReservedWord.ts
+var reservedWords = [
+  "abstract",
+  "arguments",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  "Array",
+  "Date",
+  "eval",
+  "function",
+  "hasOwnProperty",
+  "Infinity",
+  "isFinite",
+  "isNaN",
+  "isPrototypeOf",
+  "length",
+  "Math",
+  "name",
+  "NaN",
+  "Number",
+  "Object",
+  "prototype",
+  "String",
+  "toString",
+  "undefined",
+  "valueOf"
+];
+function transformReservedWord(word) {
+  if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
+    return `_${word}`;
+  }
+  return word;
+}
+
+export {
+  transformReservedWord
+};
+//# sourceMappingURL=chunk-2EU7DMPM.js.map

package/dist/chunk-2EU7DMPM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transformers/transformReservedWord.ts"],"sourcesContent":["/**\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = [\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n\n  'Array',\n  'Date',\n  'eval',\n  'function',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n]\n\nexport function transformReservedWord(word: string): string {\n  if ((word && reservedWords.includes(word)) || word?.match(/^\\d/)) {\n    return `_${word}`\n  }\n\n  return word\n}\n"],"mappings":";AAGA,IAAM,gBAAgB;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,SAAS,sBAAsB,MAAsB;AAC1D,MAAK,QAAQ,cAAc,SAAS,IAAI,KAAM,MAAM,MAAM,KAAK,GAAG;AAChE,WAAO,IAAI,IAAI;AAAA,EACjB;AAEA,SAAO;AACT;","names":[]}