@gesslar/bedoc 1.1.0 → 1.3.0

package/dist/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/cli.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "cli.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../src/cli.js"
+  ],
+  "names": [],
+  "mappings": ""
+}

package/dist/types/core/ActionManager.d.ts

@@ -0,0 +1,27 @@
+import Logger from './Logger';
+import HookManager from './HookManager';
+
+export interface ActionDefinition {
+    action: string;
+    contract: Record<string, unknown>;
+    meta: Record<string, unknown>;
+}
+
+export default class ActionManager {
+    constructor(actionDefinition: ActionDefinition, logger: Logger);
+    get action(): ActionDefinition;
+    set hookManager(hookManager: HookManager);
+    get hookManager(): HookManager;
+    get contract(): Record<string, unknown>;
+    get meta(): Record<string, unknown>;
+    get log(): Logger;
+    setupAction(): Promise<void>;
+    runAction({ file, content }: {
+        file: string;
+        content: string;
+    }): Promise<string>;
+    cleanupAction(): Promise<void>;
+    toString(): string;
+    #private;
+}
+//# sourceMappingURL=ActionManager.d.ts.map

package/dist/types/core/ActionManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ActionManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/ActionManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IAQE,gDAKC;IAsBD,kBAEC;IAMD,kCAQC;IAZD,uBAEC;IAYD,oBAEC;IAED,gBAEC;IAED,eAEC;IA0CD,6BAKC;IAED;;;qBAWC;IAED,+BAMC;IAED,mBAEC;;CACF"
+}

package/dist/types/core/Configuration.d.ts

@@ -0,0 +1,27 @@
+import { Environment } from './Core';
+
+interface ConfigurationOption {
+    value: unknown;
+    source: string;
+}
+
+interface ConfigurationOptions {
+    [key: string]: ConfigurationOption;
+}
+
+interface ValidateParams {
+    options: ConfigurationOptions;
+    source: typeof Environment;
+}
+
+interface ValidationResult {
+    status: 'success';
+    validated: boolean;
+    [key: string]: unknown;
+}
+
+export default class Configuration {
+    validate({ options, source }: ValidateParams): Promise<ValidationResult>;
+    #private;
+}
+//# sourceMappingURL=Configuration.d.ts.map

package/dist/types/core/Configuration.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Configuration.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Configuration.js"
+  ],
+  "names": [],
+  "mappings": "AAiBA;IACE;;;;;;OAqHC;;CAwMF"
+}

package/dist/types/core/ConfigurationParameters.d.ts

@@ -0,0 +1,38 @@
+import TypeSpec from './util/TypeSpec';
+
+interface PathConfig {
+    type: 'file' | 'directory';
+    mustExist: boolean;
+}
+
+interface ConfigurationParameter {
+    short: string;
+    param?: string;
+    description: string;
+    type: TypeSpec;
+    required: boolean;
+    default?: boolean | number | string;
+    path?: PathConfig;
+    exclusiveOf?: string;
+}
+
+interface ConfigurationParametersType {
+    input: ConfigurationParameter;
+    exclude: ConfigurationParameter;
+    language: ConfigurationParameter;
+    format: ConfigurationParameter;
+    maxConcurrent: ConfigurationParameter;
+    hooks: ConfigurationParameter;
+    output: ConfigurationParameter;
+    parser: ConfigurationParameter;
+    printer: ConfigurationParameter;
+    hookTimeout: ConfigurationParameter;
+    mock: ConfigurationParameter;
+    config: ConfigurationParameter;
+    debug: ConfigurationParameter;
+    debugLevel: ConfigurationParameter;
+}
+
+export const ConfigurationParameters: Readonly<ConfigurationParametersType>;
+export const ConfigurationPriorityKeys: readonly ['exclude', 'input'];
+//# sourceMappingURL=ConfigurationParameters.d.ts.map

package/dist/types/core/ConfigurationParameters.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ConfigurationParameters.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/ConfigurationParameters.js"
+  ],
+  "names": [],
+  "mappings": "AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqIE;AAEF,0DAAqE"
+}

package/dist/types/core/Conveyor.d.ts

@@ -0,0 +1,47 @@
+import ActionManager from './ActionManager';
+import Logger from './Logger';
+import { FileMap } from './util/FDUtil';
+
+interface ProcessResult {
+    status: 'success' | 'error' | 'warning';
+    file?: FileMap;
+    error?: Error;
+    warning?: string;
+    result?: string;
+    destFile?: string;
+    content?: string;
+}
+
+interface ConveyResult {
+    succeeded: Array<{ input: FileMap; output: FileMap }>;
+    errored: Array<{ input: FileMap; error: Error }>;
+}
+
+export default class Conveyor {
+    constructor(
+        parse: ActionManager,
+        print: ActionManager,
+        logger: Logger,
+        output: FileMap
+    );
+
+    readonly parse: ActionManager;
+    readonly print: ActionManager;
+    readonly logger: Logger;
+    readonly output: FileMap;
+
+    /**
+     * Processes files with a concurrency limit.
+     *
+     * @param files - List of files to process.
+     * @param maxConcurrent - Maximum number of concurrent tasks.
+     * @returns Resolves when all files are processed.
+     */
+    convey(files: FileMap[], maxConcurrent?: number): Promise<ConveyResult>;
+
+    #succeeded: Array<{ input: FileMap; output: FileMap }>;
+    #errored: Array<{ input: FileMap; error: Error }>;
+    #processFile(file: FileMap): Promise<ProcessResult>;
+    #writeOutput(destFile: string, content: string): Promise<ProcessResult>;
+}
+//# sourceMappingURL=Conveyor.d.ts.map

package/dist/types/core/Conveyor.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Conveyor.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Conveyor.js"
+  ],
+  "names": [],
+  "mappings": "AAMA;IAIE,8DAKC;IAJC,WAAkB;IAClB,WAAkB;IAClB,YAAoB;IACpB,YAAoB;IAGtB;;;;;;OAMG;IACH,qCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CA8B3B;;CAgFF"
+}

package/dist/types/core/Core.d.ts

@@ -0,0 +1,53 @@
+import Logger from './Logger';
+import ActionManager from './ActionManager';
+import { FileMap } from './util/FDUtil';
+
+export const Environment: Readonly<{
+    EXTENSION: 'extension';
+    NPM: 'npm';
+    ACTION: 'action';
+    CLI: 'cli';
+}>;
+
+export type EnvironmentType = typeof Environment[keyof typeof Environment];
+
+interface CoreOptions {
+    debug?: boolean;
+    debugLevel?: number;
+    name?: string;
+    [key: string]: unknown;
+}
+
+interface CoreConstructorOptions extends CoreOptions {
+    hooks?: string;
+    hooksTimeout?: number;
+    output?: string;
+    maxConcurrent?: number;
+}
+
+interface NewParams {
+    options: CoreOptions;
+    source: EnvironmentType;
+}
+
+interface ProcessResult {
+    succeeded: Array<{ input: FileMap; output: FileMap }>;
+    errored: Array<{ input: FileMap; error: Error }>;
+}
+
+export default class Core {
+    static new({ options, source }: NewParams): Promise<Core>;
+
+    constructor(options: CoreConstructorOptions);
+
+    readonly options: CoreConstructorOptions;
+    readonly logger: Logger;
+    readonly packageJson: Record<string, unknown>;
+    readonly debugOptions: {
+        name: string | null;
+        debugLevel: number;
+    };
+    readonly actions: Record<string, ActionManager>;
+
+    processFiles(glob: string | string[], startTime?: [number, number]): Promise<ProcessResult>;
+}

package/dist/types/core/Core.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Core.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Core.js"
+  ],
+  "names": [],
+  "mappings": "AAkBA;;;;;GAKE;AAEF;IASE;;;sBAoFC;IA5FD,0BAMC;IALC,aAAsB;IAEtB,eAAgE;IAChE,iBAAiD;IACjD;;;MAAuC;IAyFzC;;;OAsDC;CACF;mBA3KkB,aAAa"
+}

package/dist/types/core/Discovery.d.ts

@@ -0,0 +1,73 @@
+import Core from './Core';
+import { FileMap } from './util/FDUtil';
+import ActionManager from './ActionManager';
+
+interface DiscoveryOptions {
+    print?: FileMap;
+    parse?: FileMap;
+}
+
+interface ActionDefinition {
+    file: FileMap;
+    action: {
+        meta: {
+            action: string;
+            [key: string]: unknown;
+        };
+    };
+    contract: Record<string, unknown>;
+}
+
+interface ActionMap {
+    print: ActionDefinition[];
+    parse: ActionDefinition[];
+    [key: string]: ActionDefinition[];
+}
+
+interface ValidCriteria {
+    parse: ActionDefinition[];
+    print: ActionDefinition[];
+}
+
+export default class Discovery {
+    constructor(core: Core);
+    readonly core: Core;
+
+    /**
+     * Discover actions from local or global node_modules
+     *
+     * @param specific Configuration options for action discovery
+     * @returns A map of discovered modules
+     */
+    discoverActions(specific?: DiscoveryOptions): Promise<ActionMap>;
+
+    /**
+     * Check which actions satisfy the configuration criteria
+     */
+    satisfyCriteria(actions: ActionMap, validatedConfig: Record<string, unknown>): ValidCriteria;
+
+    #loadModule(module: FileMap): Promise<{
+        file: FileMap;
+        actions: ActionManager[];
+        contracts: string[];
+    }>;
+
+    #getModuleExports(dirMap: FileMap): FileMap[];
+
+    #loadActionsAndContracts(
+        moduleFiles: FileMap[],
+        specific: {
+            print?: FileMap;
+            parse?: FileMap;
+        }
+    ): Promise<ActionMap>;
+
+    #validMeta(
+        actionType: string,
+        toValidate: {
+            action: ActionDefinition['action'];
+            contract: ActionDefinition['contract'];
+        }
+    ): boolean;
+}
+//# sourceMappingURL=Discovery.d.ts.map

package/dist/types/core/Discovery.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Discovery.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Discovery.js"
+  ],
+  "names": [],
+  "mappings": "AAYA;IAIE,uBAIC;IAHC,UAAgB;IAKlB;;;;;;;OAOG;IACH,0BAJG;QAAyB,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;KACd,GAAU,OAAO,CAAC,MAAM,CAAC,CAsE3B;IA6JD;;;MAiDC;;CA4DF"
+}

package/dist/types/core/HookManager.d.ts

@@ -0,0 +1,60 @@
+import Logger from './Logger';
+import { FileMap } from './util/FDUtil';
+
+type HookEvent = 'start' | 'section_load' | 'enter' | 'exit' | 'end';
+
+interface HookResult {
+    status?: 'success' | 'error';
+    error?: Error;
+    [key: string]: unknown;
+}
+
+interface HooksDefinition {
+    setup?: () => Promise<void>;
+    cleanup?: () => Promise<void>;
+    start?: (...args: unknown[]) => Promise<HookResult>;
+    section_load?: (...args: unknown[]) => Promise<HookResult>;
+    enter?: (...args: unknown[]) => Promise<HookResult>;
+    exit?: (...args: unknown[]) => Promise<HookResult>;
+    end?: (...args: unknown[]) => Promise<HookResult>;
+    log?: Logger;
+}
+
+interface HookManagerConstructorParams {
+    action: string;
+    hooksFile: FileMap;
+    logger: Logger;
+    timeOut: number;
+}
+
+export const hookPoints: Readonly<Record<Uppercase<HookEvent>, HookEvent>>;
+
+export default class HookManager {
+    static new(arg: HookManagerConstructorParams): Promise<HookManager | null>;
+
+    constructor({ action, hooksFile, logger, timeOut: timeout }: HookManagerConstructorParams);
+
+    get action(): string;
+    get hooksFile(): FileMap;
+    get hooks(): HooksDefinition | null;
+    get log(): Logger;
+    get timeout(): number;
+    get setup(): (() => Promise<void>) | null;
+    get cleanup(): (() => Promise<void>) | null;
+
+    /**
+     * Trigger a hook
+     *
+     * @param event - The type of hook to trigger
+     * @param args - The hook arguments
+     * @returns The result of the hook
+     */
+    on(event: HookEvent, ...args: unknown[]): Promise<HookResult | undefined>;
+
+    #hooksFile: FileMap | null;
+    #log: Logger | null;
+    #hooks: HooksDefinition | null;
+    #action: string | null;
+    #timeout: number;
+}
+//# sourceMappingURL=HookManager.d.ts.map

package/dist/types/core/HookManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "HookManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/HookManager.js"
+  ],
+  "names": [],
+  "mappings": "AAUA,sCAKC;AAED;IA0CE,6CAsCC;IAzED;;;;;OAKC;IAED,kBAEC;IAED,qBAEC;IAED,iBAEC;IAED,eAEC;IAED,sBAEC;IAED,iBAEC;IAED,mBAEC;IA0CD;;;;;;OAMG;IACH,UAJW,MAAM,WACH,GAAG,EAAA,GACJ,OAAO,CAAC,GAAG,CAAC,CAsCxB;;CACF"
+}

package/dist/types/core/Logger.d.ts

@@ -0,0 +1,55 @@
+import ErrorStackParser from 'error-stack-parser';
+import * as vscode from 'vscode';
+
+interface LoggerOptions {
+    name?: string;
+    debugLevel?: number;
+    env?: string;
+}
+
+type LogLevel = 'debug' | 'warn' | 'info' | 'error';
+type DebugLevel = 0 | 1 | 2 | 3 | 4;
+
+/**
+ * Logger class
+ *
+ * Log levels:
+ * - debug: Debugging information
+ *   - Debug levels
+ *     - 0: No/critical debug information, not error level, but should be logged
+ *     - 1: Basic debug information, startup, shutdown, etc
+ *     - 2: Intermediate debug information, discovery
+ *     - 3: Detailed debug information, parsing, processing, etc
+ *     - 4: Very detailed debug information, nerd mode!
+ * - warn: Warning information
+ * - info: Informational information
+ * - error: Error information
+ */
+export default class Logger {
+    constructor(options?: LoggerOptions);
+
+    readonly vscodeError?: typeof vscode.window.showErrorMessage;
+    readonly vscodeWarn?: typeof vscode.window.showWarningMessage;
+    readonly vscodeInfo?: typeof vscode.window.showInformationMessage;
+
+    get name(): string;
+    get debugLevel(): number;
+    get options(): Required<Pick<LoggerOptions, 'name' | 'debugLevel'>>;
+
+    setOptions(options: LoggerOptions): void;
+
+    lastStackLine(error?: Error, stepsRemoved?: number): ErrorStackParser.StackFrame;
+    extractFileFunction(level?: DebugLevel): string;
+
+    newDebug(tag?: string): (message: string, level?: DebugLevel, ...args: unknown[]) => void;
+
+    debug(message: string, level?: DebugLevel, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+
+    #name: string | null;
+    #debugLevel: number;
+    #compose(level: LogLevel, message: string, debugLevel?: DebugLevel): string;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/types/core/Logger.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "Logger.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../src/core/Logger.js"
+  ],
+  "names": [],
+  "mappings": "AAkDA;;;;;;;;;;;;;;;;GAgBG;AAEH;IAIE,0BAWC;IALK,iBAAiD;IACjD,gBAAkD;IAClD,gBAAsD;IAK5D,gBAEC;IAED,yBAEC;IAED;;;MAKC;IAED,+BAGC;IAWD,iFAGC;IAED,4CAoCC;IAED,wBAKC;IAED,yDAGC;IAED,wCAGC;IAED,wCAGC;IAED,yCAGC;;CACF;6BA7J4B,oBAAoB"
+}

package/dist/types/core/action/ParseManager.d.ts

@@ -0,0 +1,8 @@
+import ActionManager from '../ActionManager';
+import Logger from '../Logger';
+import { ActionDefinition } from "../ActionManager";
+
+export default class ParseManager extends ActionManager {
+    constructor(actionDefinition: ActionDefinition, logger: Logger);
+}
+//# sourceMappingURL=ParseManager.d.ts.map

package/dist/types/core/action/ParseManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ParseManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/action/ParseManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IACE,gDAEC;CACF;0BANyB,qBAAqB"
+}

package/dist/types/core/action/PrintManager.d.ts

@@ -0,0 +1,8 @@
+import ActionManager from '../ActionManager';
+import Logger from '../Logger';
+import { ActionDefinition } from "../ActionManager";
+
+export default class PrintManager extends ActionManager {
+    constructor(actionDefinition: ActionDefinition, logger: Logger);
+}
+//# sourceMappingURL=PrintManager.d.ts.map

package/dist/types/core/action/PrintManager.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "PrintManager.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/action/PrintManager.js"
+  ],
+  "names": [],
+  "mappings": "AAEA;IACE,gDAEC;CACF;0BANyB,qBAAqB"
+}

package/dist/types/core/util/ActionUtil.d.ts

@@ -0,0 +1,35 @@
+import { FileMap } from './FDUtil';
+
+type ActionType = 'parse' | 'print';
+
+interface ActionMeta {
+    action: ActionType;
+    language?: string;
+    format?: string;
+}
+
+interface ActionRequirement {
+    action: ActionType;
+}
+
+type ActionMetaRequirement = ActionRequirement | keyof ActionMeta;
+
+export const actionMetaRequirements: Readonly<Record<ActionType, ActionMetaRequirement[]>>;
+export const actionTypes: readonly ActionType[];
+
+/**
+ * Loads a JSON file asynchronously
+ *
+ * @param jsonFileObject - The JSON file to load
+ * @returns The parsed JSON content
+ */
+export function loadJson(jsonFileObject: FileMap): Record<string, unknown>;
+
+/**
+ * Loads the package.json file asynchronously
+ *
+ * @param basePath - The base path to use
+ * @returns The parsed package.json content
+ */
+export function loadPackageJson(basePath?: string | FileMap | null): Record<string, unknown>;
+//# sourceMappingURL=ActionUtil.d.ts.map

package/dist/types/core/util/ActionUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "ActionUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/ActionUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAQA;;;;;;;GAGE;AALF,4CAA8C;AAO9C;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;GAKG;AACH,2CAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAOlB"
+}

package/dist/types/core/util/DataUtil.d.ts

@@ -0,0 +1,52 @@
+import Logger from '../Logger';
+import TypeSpec from './TypeSpec';
+
+type PrimitiveType = 'undefined' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'object' | 'function';
+type ConstructorType = 'object' | 'array' | 'function' | 'date' | 'regexp' | 'error' | 'map' | 'set' | 'weakmap' | 'weakset' | 'promise' | 'int8array' | 'uint8array' | 'float32array' | 'float64array';
+type DataType = PrimitiveType | ConstructorType;
+
+export const dataTypes: readonly DataType[];
+export const emptyableTypes: readonly ['string', 'array', 'object'];
+
+interface TypeSpecOptions {
+    allowEmpty?: boolean;
+}
+
+interface SchemaCompareResult {
+    status: 'success' | 'error';
+    errors: Error[];
+}
+
+export function allocateObject<T>(source: string[], spec: T[] | ((source: string[]) => Promise<T[]>)): Promise<Record<string, T>>;
+export function appendString(str: string, append: string): string;
+export function prependString(str: string, prepend: string): string;
+export function arrayIntersection<T>(arr1: T[], arr2: T[]): T[];
+export function arrayPad<T>(arr: T[], length: number, value: T, position?: 0 | -1): T[];
+export function isArrayUniform(arr: unknown[], type?: string): boolean;
+export function isArrayUnique<T>(arr: T[]): T[];
+
+export function cloneObject<T extends Record<string, unknown>>(obj: T, freeze?: boolean): T;
+export function deepFreezeObject<T extends Record<string, unknown>>(obj: T): Readonly<T>;
+export function isObjectEmpty(obj: Record<string, unknown>): boolean;
+
+export function mapObject<T extends Record<string, unknown>>(
+    original: T,
+    transformer: (key: string, value: unknown) => Promise<unknown>,
+    mutate?: boolean
+): Promise<T>;
+
+export function isNothing(value: unknown): value is null | undefined;
+export function isEmpty(value: unknown, checkForNothing?: boolean): boolean;
+export function isType(value: unknown, type: string | TypeSpec, options: TypeSpecOptions): boolean;
+export function isBaseType(value: unknown, type: DataType): boolean;
+export function isValidType(type: string): type is DataType;
+export function typeOf(value: unknown): DataType;
+
+export function newTypeSpec(str: string, options?: TypeSpecOptions): TypeSpec;
+
+export function schemaCompare(
+    schema: Record<string, unknown>,
+    definition: Record<string, unknown>,
+    stack?: string[],
+    logger?: Logger
+): SchemaCompareResult;

package/dist/types/core/util/DataUtil.d.ts.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "DataUtil.d.ts",
+  "sourceRoot": "",
+  "sources": [
+    "../../../../src/core/util/DataUtil.js"
+  ],
+  "names": [],
+  "mappings": "AAwCA,iCAA8E;AAE9E,sCAAoD;AAwGpD;;;;;;GAMG;AACH,uCAJW,GAAG,QACH,GAAG,WAAS,GACV,OAAO,CAAC,MAAM,CAAC,CA2C3B;AAtJD;;;;;;GAMG;AACH,qCAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;AAqCD;;;;;;GAMG;AACH,mEAEC;AAED;;;;;;;;;GASG;AACH,6CALW,MAAM,SACN,GAAG,aACH,MAAM,SAgBhB;AAED;;;;;;GAMG;AACH,iCAJW,MAAM,WACN,OAAO,GACL,MAAM,CAalB;AAqND;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,MAAM,CAmBlB;AA1TD;;;;;;;GAOG;AACH,iDAJW,MAAM,GAEJ,OAAO,CAMnB;AAED;;;;;GAKG;AACH,iDAEC;AAkLD;;;;;;;;GAQG;AACH,kCAJW,GAAG,QACH,MAAM,GACJ,OAAO,CAgCnB;AAsBD;;;;;;;;GAQG;AACH,+BALW,GAAG,oBACH,OAAO,GAEL,OAAO,CAqBnB;AAtCD;;;;;GAKG;AACH,iCAHW,GAAG,GACD,OAAO,CAInB;AA1GD;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,OAAO,CAInB;AAcD;;;;;;;GAOG;AACH,8BALW,GAAG,QACH,MAAM,GAAC,QAAQ,WACf,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,GACJ,OAAO,CAInB;AApED;;;;;;;GAOG;AACH,oCALW,MAAM,kCAEN,OAAO,GACL,OAAO,CAAC,MAAM,CAAC,CAe3B;AAYD;;;;;;;GAOG;AACH,oCAJW,MAAM,WACN,MAAM,GACJ,MAAM,EAAE,CAIpB;AAxLD;;;;;;GAMG;AACH,sCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAIlB;AA8TD;;;;;;;;GAQG;AACH,sCANW,MAAM,cACN,MAAM,0BAEN,MAAM,GACJ,OAAO,CA+DnB;AAjJD;;;;;GAKG;AACH,8BAHW,GAAG,GACD,MAAM,CAIlB;qBA1ToB,eAAe"
+}