@docker-harpoon/core 0.1.0

package/dist/dockerfile-transformers/core.js

@@ -0,0 +1,271 @@
+/**
+ * Dockerfile Transformer Core
+ *
+ * Core parsing, serialization, and pipeline utilities for Dockerfile transformation.
+ * This module provides the foundation for all Dockerfile transformers.
+ */
+import { Effect } from 'effect';
+import { TransformerError } from './types';
+// ============ Parsing ============
+/**
+ * Parses Dockerfile arguments, handling quoted strings.
+ */
+function parseArgs(argString) {
+    const args = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+    for (let i = 0; i < argString.length; i++) {
+        const char = argString[i];
+        if (!inQuotes && (char === '"' || char === "'")) {
+            inQuotes = true;
+            quoteChar = char;
+            current += char;
+        }
+        else if (inQuotes && char === quoteChar) {
+            inQuotes = false;
+            quoteChar = '';
+            current += char;
+        }
+        else if (!inQuotes && char === ' ') {
+            if (current.trim()) {
+                args.push(current.trim());
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        args.push(current.trim());
+    }
+    return args;
+}
+/**
+ * Maps a string to a DockerfileInstruction type.
+ */
+function mapInstructionType(type) {
+    const upperType = type.toUpperCase();
+    switch (upperType) {
+        case 'COPY':
+            return 'COPY';
+        case 'RUN':
+            return 'RUN';
+        case 'ENV':
+            return 'ENV';
+        case 'CMD':
+            return 'CMD';
+        case 'WORKDIR':
+            return 'WORKDIR';
+        case 'FROM':
+            return 'FROM';
+        case 'ARG':
+            return 'ARG';
+        case 'EXPOSE':
+            return 'EXPOSE';
+        case 'HEALTHCHECK':
+            return 'HEALTHCHECK';
+        default:
+            return 'OTHER';
+    }
+}
+/**
+ * Parses a Dockerfile into structured instructions.
+ * Pure function - synchronous for direct use.
+ *
+ * @param dockerfile Raw Dockerfile content
+ * @returns Array of parsed instructions
+ */
+export function parseDockerfile(dockerfile) {
+    const lines = dockerfile.split('\n');
+    const instructions = [];
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        // Handle line continuations ending with '\'
+        while (line.trimEnd().endsWith('\\')) {
+            const nextLine = lines[++i];
+            if (nextLine === undefined) {
+                break;
+            }
+            line = `${line.trimEnd().slice(0, -1)} ${nextLine.trim()}`;
+        }
+        line = line.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const match = line.match(/^(\w+)(?:\s+(.+))?$/);
+        if (!match || !match[1]) {
+            instructions.push({
+                type: 'OTHER',
+                args: Object.freeze([]),
+                original: line,
+                lineNumber: i + 1,
+            });
+            continue;
+        }
+        const type = match[1];
+        const rest = match[2];
+        const instructionType = mapInstructionType(type);
+        const args = rest ? parseArgs(rest) : [];
+        instructions.push({
+            type: instructionType,
+            args: Object.freeze(args),
+            original: line,
+            lineNumber: i + 1,
+        });
+    }
+    return instructions;
+}
+/**
+ * Effect-wrapped parser for composable error handling.
+ */
+export function parseDockerfileEffect(dockerfile) {
+    return Effect.try({
+        try: () => parseDockerfile(dockerfile),
+        catch: (error) => new TransformerError('core-parser', `Failed to parse Dockerfile: ${error}`, undefined, error instanceof Error ? error : undefined),
+    });
+}
+// ============ Serialization ============
+/**
+ * Serializes instructions back to Dockerfile format.
+ *
+ * @param instructions Parsed Dockerfile instructions
+ * @returns Dockerfile content as string
+ */
+export function serializeDockerfile(instructions) {
+    return instructions.map((inst) => inst.original).join('\n');
+}
+// ============ Pipeline ============
+/**
+ * Creates a new transformation pipeline.
+ *
+ * @param transformers Initial transformers to add
+ * @returns A TransformPipeline instance
+ */
+export function createPipeline(transformers = []) {
+    const pipelineTransformers = [...transformers];
+    const add = (transformer) => {
+        pipelineTransformers.push(transformer);
+        return pipeline;
+    };
+    const transform = (dockerfile, ctx) => {
+        return Effect.gen(function* () {
+            // Parse Dockerfile
+            const instructions = yield* parseDockerfileEffect(dockerfile);
+            // Track current stage for context
+            let currentStage;
+            const transformedInstructions = [];
+            for (const inst of instructions) {
+                // Track stage transitions
+                if (inst.type === 'FROM' &&
+                    inst.original.toLowerCase().includes(' as ')) {
+                    const stageMatch = inst.original.match(/\s+as\s+(\w+)/i);
+                    if (stageMatch) {
+                        currentStage = stageMatch[1];
+                    }
+                }
+                // Create context with current stage
+                const instCtx = currentStage
+                    ? { ...ctx, currentStage }
+                    : ctx;
+                // Apply matching transformers
+                let current = [inst];
+                for (const transformer of pipelineTransformers) {
+                    const next = [];
+                    for (const currentInst of current) {
+                        // Check if transformer handles this instruction type
+                        if (!transformer.handlesTypes.includes(currentInst.type)) {
+                            next.push(currentInst);
+                            continue;
+                        }
+                        // Check if transformer matches this instruction
+                        if (!transformer.matches(currentInst, instCtx)) {
+                            next.push(currentInst);
+                            continue;
+                        }
+                        // Apply transformation
+                        const result = transformer.transform(currentInst, instCtx);
+                        // Check if result is an array (has 'type' means it's a single instruction)
+                        if ('type' in result && typeof result.type === 'string') {
+                            next.push(result);
+                        }
+                        else {
+                            for (const r of result) {
+                                next.push(r);
+                            }
+                        }
+                    }
+                    current = next;
+                }
+                transformedInstructions.push(...current);
+            }
+            return serializeDockerfile(transformedInstructions);
+        });
+    };
+    const pipeline = {
+        add,
+        transform,
+        get transformers() {
+            return Object.freeze([...pipelineTransformers]);
+        },
+    };
+    return pipeline;
+}
+/**
+ * Transform a Dockerfile using a pipeline and return full result.
+ */
+export function transformDockerfile(dockerfile, ctx, pipeline) {
+    return Effect.gen(function* () {
+        const transformedDockerfile = yield* pipeline.transform(dockerfile, ctx);
+        return {
+            transformedDockerfile,
+            context: ctx,
+            appliedTransformers: pipeline.transformers.map((t) => t.name),
+        };
+    });
+}
+// ============ Utility Functions ============
+/**
+ * Creates a simple instruction that replaces the original line.
+ */
+export function replaceInstruction(inst, newOriginal, newArgs) {
+    return {
+        ...inst,
+        original: newOriginal,
+        args: newArgs ? Object.freeze([...newArgs]) : inst.args,
+    };
+}
+/**
+ * Creates multiple instructions from one (for splitting).
+ */
+export function splitInstruction(inst, replacements) {
+    return replacements.map((r) => ({
+        type: inst.type,
+        args: r.args ? Object.freeze([...r.args]) : Object.freeze([]),
+        original: r.original,
+        lineNumber: inst.lineNumber,
+    }));
+}
+/**
+ * Check if an instruction's args contain a pattern.
+ */
+export function argsContain(inst, pattern) {
+    return inst.args.some((arg) => {
+        if (!arg)
+            return false;
+        if (typeof pattern === 'string') {
+            return arg.includes(pattern);
+        }
+        return pattern.test(arg);
+    });
+}
+/**
+ * Get a specific argument by index (0-based).
+ */
+export function getArg(inst, index) {
+    return inst.args[index];
+}

package/dist/dockerfile-transformers/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Dockerfile Transformers Registry
+ *
+ * Central registry for Dockerfile instruction transformers.
+ * Provides pipeline building and transformer lookup.
+ *
+ * Note: Tool-specific transformers (Prisma, Next.js, etc.) are provided
+ * by their respective binding packages (@harpoon/prisma, @harpoon/nextjs, etc.)
+ */
+import type { InstructionTransformer, TransformerRegistry, TransformPipeline, DockerfileInstruction } from './types';
+export { TransformerError } from './types';
+export type { InstructionTransformer, DockerfileInstruction, TransformContext, TransformerRegistry, TransformPipeline, TransformResult, } from './types';
+export { parseDockerfile, parseDockerfileEffect, serializeDockerfile, createPipeline, transformDockerfile, replaceInstruction, splitInstruction, argsContain, getArg, } from './core';
+/**
+ * Transformer registry singleton.
+ */
+export declare const transformerRegistry: TransformerRegistry;
+/**
+ * Register an instruction transformer.
+ */
+export declare function registerTransformer(transformer: InstructionTransformer): void;
+/**
+ * Get a transformer by name.
+ */
+export declare function getTransformer(name: string): InstructionTransformer | undefined;
+/**
+ * List all registered transformer names.
+ */
+export declare function listTransformers(): readonly string[];
+/**
+ * Get all transformers that handle a specific instruction type.
+ */
+export declare function getTransformersForType(type: DockerfileInstruction['type']): readonly InstructionTransformer[];
+/**
+ * Create a pipeline with all registered transformers.
+ */
+export declare function createDefaultPipeline(): TransformPipeline;
+/**
+ * Create a pipeline with specific transformers by name.
+ */
+export declare function createPipelineWithTransformers(names: readonly string[]): TransformPipeline;
+//# sourceMappingURL=index.d.ts.map

package/dist/dockerfile-transformers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dockerfile-transformers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC3C,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,EACX,MAAM,GACP,MAAM,QAAQ,CAAC;AAMhB;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAajC,CAAC;AAEF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,sBAAsB,GAAG,IAAI,CAE7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,SAAS,CAEpC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,SAAS,MAAM,EAAE,CAEpD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,qBAAqB,CAAC,MAAM,CAAC,GAClC,SAAS,sBAAsB,EAAE,CAEnC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,iBAAiB,CAGzD;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,iBAAiB,CAMnB"}

package/dist/dockerfile-transformers/index.js

@@ -0,0 +1,67 @@
+/**
+ * Dockerfile Transformers Registry
+ *
+ * Central registry for Dockerfile instruction transformers.
+ * Provides pipeline building and transformer lookup.
+ *
+ * Note: Tool-specific transformers (Prisma, Next.js, etc.) are provided
+ * by their respective binding packages (@harpoon/prisma, @harpoon/nextjs, etc.)
+ */
+// Re-export types
+export { TransformerError } from './types';
+// Re-export core utilities
+export { parseDockerfile, parseDockerfileEffect, serializeDockerfile, createPipeline, transformDockerfile, replaceInstruction, splitInstruction, argsContain, getArg, } from './core';
+// ============ Registry Implementation ============
+const transformers = new Map();
+/**
+ * Transformer registry singleton.
+ */
+export const transformerRegistry = {
+    get: (name) => transformers.get(name),
+    register: (transformer) => {
+        transformers.set(transformer.name, transformer);
+    },
+    list: () => Object.freeze([...transformers.keys()]),
+    getForType: (type) => Object.freeze([...transformers.values()].filter((t) => t.handlesTypes.includes(type))),
+};
+/**
+ * Register an instruction transformer.
+ */
+export function registerTransformer(transformer) {
+    transformerRegistry.register(transformer);
+}
+/**
+ * Get a transformer by name.
+ */
+export function getTransformer(name) {
+    return transformerRegistry.get(name);
+}
+/**
+ * List all registered transformer names.
+ */
+export function listTransformers() {
+    return transformerRegistry.list();
+}
+/**
+ * Get all transformers that handle a specific instruction type.
+ */
+export function getTransformersForType(type) {
+    return transformerRegistry.getForType(type);
+}
+/**
+ * Create a pipeline with all registered transformers.
+ */
+export function createDefaultPipeline() {
+    const { createPipeline } = require('./core');
+    return createPipeline([...transformers.values()]);
+}
+/**
+ * Create a pipeline with specific transformers by name.
+ */
+export function createPipelineWithTransformers(names) {
+    const { createPipeline } = require('./core');
+    const selected = names
+        .map((name) => transformers.get(name))
+        .filter((t) => t !== undefined);
+    return createPipeline(selected);
+}

package/dist/dockerfile-transformers/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Dockerfile Transformer Types
+ *
+ * Interfaces for composable Dockerfile instruction transformers.
+ * Transformers modify individual Dockerfile instructions.
+ */
+import { Effect } from 'effect';
+/**
+ * Parsed Dockerfile instruction.
+ */
+export interface DockerfileInstruction {
+    readonly type: 'COPY' | 'RUN' | 'ENV' | 'CMD' | 'WORKDIR' | 'FROM' | 'ARG' | 'EXPOSE' | 'HEALTHCHECK' | 'OTHER';
+    readonly args: readonly (string | undefined)[];
+    readonly original: string;
+    readonly lineNumber: number;
+}
+/**
+ * Context provided during Dockerfile transformation.
+ */
+export interface TransformContext {
+    /** Name of the app being built */
+    readonly appName: string;
+    /** Folders copied to the build context */
+    readonly copiedFolders: readonly string[];
+    /** Root files copied to the build context */
+    readonly copiedRootFiles: readonly string[];
+    /** Source directory for shared folders */
+    readonly sharedSource: string;
+    /** Temp directory for build context */
+    readonly tempDir: string;
+    /** Whether this is a standalone app (vs already monorepo) */
+    readonly isStandaloneApp?: boolean;
+    /** Current stage name (e.g., 'builder', 'runner') */
+    readonly currentStage?: string;
+    /** Additional metadata */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Error during Dockerfile transformation.
+ */
+export declare class TransformerError extends Error {
+    readonly _tag: "TransformerError";
+    readonly transformerName: string;
+    readonly instruction?: DockerfileInstruction | undefined;
+    readonly cause?: Error | undefined;
+    constructor(transformerName: string, message: string, instruction?: DockerfileInstruction, cause?: Error);
+}
+/**
+ * A single Dockerfile instruction transformer.
+ *
+ * Transformers are applied to individual instructions and can:
+ * - Return the instruction unchanged
+ * - Return a modified instruction
+ * - Return multiple instructions (splitting)
+ * - Return an empty array (removing the instruction)
+ */
+export interface InstructionTransformer {
+    /** Unique transformer identifier */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** Instruction types this transformer handles */
+    readonly handlesTypes: readonly DockerfileInstruction['type'][];
+    /**
+     * Check if this transformer should process the instruction.
+     *
+     * @param inst The Dockerfile instruction
+     * @param ctx Transform context
+     * @returns true if transformer should handle this instruction
+     */
+    readonly matches: (inst: DockerfileInstruction, ctx: TransformContext) => boolean;
+    /**
+     * Transform the instruction.
+     *
+     * @param inst The Dockerfile instruction
+     * @param ctx Transform context
+     * @returns Transformed instruction(s) or empty array to remove
+     */
+    readonly transform: (inst: DockerfileInstruction, ctx: TransformContext) => DockerfileInstruction | readonly DockerfileInstruction[];
+}
+/**
+ * Registry of instruction transformers.
+ */
+export interface TransformerRegistry {
+    /** Get a transformer by name */
+    readonly get: (name: string) => InstructionTransformer | undefined;
+    /** Register a new transformer */
+    readonly register: (transformer: InstructionTransformer) => void;
+    /** List all registered transformer names */
+    readonly list: () => readonly string[];
+    /** Get transformers that handle a specific instruction type */
+    readonly getForType: (type: DockerfileInstruction['type']) => readonly InstructionTransformer[];
+}
+/**
+ * A transformation pipeline that applies multiple transformers.
+ */
+export interface TransformPipeline {
+    /** Add a transformer to the pipeline */
+    readonly add: (transformer: InstructionTransformer) => TransformPipeline;
+    /** Transform an entire Dockerfile */
+    readonly transform: (dockerfile: string, ctx: TransformContext) => Effect.Effect<string, TransformerError>;
+    /** Get all transformers in the pipeline */
+    readonly transformers: readonly InstructionTransformer[];
+}
+/**
+ * Result of transforming a Dockerfile.
+ */
+export interface TransformResult {
+    /** The transformed Dockerfile content */
+    readonly transformedDockerfile: string;
+    /** Context used for transformation */
+    readonly context: TransformContext;
+    /** Transformers that were applied */
+    readonly appliedTransformers: readonly string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dockerfile-transformers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dockerfile-transformers/types.ts"],"names":[],"mappings":"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"}

package/dist/dockerfile-transformers/types.js

@@ -0,0 +1,29 @@
+/**
+ * Dockerfile Transformer Types
+ *
+ * Interfaces for composable Dockerfile instruction transformers.
+ * Transformers modify individual Dockerfile instructions.
+ */
+/**
+ * Error during Dockerfile transformation.
+ */
+export class TransformerError extends Error {
+    _tag = 'TransformerError';
+    transformerName;
+    instruction;
+    cause;
+    constructor(transformerName, message, instruction, cause) {
+        super(message);
+        this.name = 'TransformerError';
+        this.transformerName = transformerName;
+        if (instruction) {
+            this.instruction = instruction;
+        }
+        if (cause) {
+            this.cause = cause;
+        }
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Harpoon Core Error Classes
+ *
+ * Typed error classes for Docker resource operations.
+ * Provides clear error categorization.
+ */
+/**
+ * Base error class for all Harpoon errors.
+ */
+export declare class HarpoonError extends Error {
+    /** Effect integration discriminant */
+    readonly _tag: string;
+    /** Resource identifier that caused the error */
+    readonly resource: string;
+    /** Original error that caused this error */
+    readonly cause?: Error;
+    constructor(message: string, resource: string, cause?: Error);
+}
+/**
+ * Error during network operations.
+ */
+export declare class NetworkError extends HarpoonError {
+    readonly _tag: 'NetworkError';
+    constructor(name: string, message?: string, cause?: Error);
+}
+/**
+ * Error during image build operations.
+ */
+export declare class ImageError extends HarpoonError {
+    readonly _tag: 'ImageError';
+    constructor(tag: string, message?: string, cause?: Error);
+}
+/**
+ * Error during container operations.
+ */
+export declare class ContainerError extends HarpoonError {
+    readonly _tag: 'ContainerError';
+    constructor(name: string, message?: string, cause?: Error);
+}
+/**
+ * Error during scope operations.
+ */
+export declare class ScopeError extends HarpoonError {
+    readonly _tag: 'ScopeError';
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Error during binding operations.
+ */
+export declare class BindingError extends HarpoonError {
+    readonly _tag: 'BindingError';
+    readonly bindingType: string;
+    constructor(bindingType: string, message: string, cause?: Error);
+}
+/**
+ * Convert an unknown error to an Error instance for use as cause.
+ * Preserves Error instances, wraps non-Errors in new Error.
+ */
+export declare function asCause(error: unknown): Error;
+/**
+ * Transform an unknown error into a typed HarpoonError.
+ */
+export declare function toHarpoonError(error: unknown, resource: string, ErrorClass?: typeof HarpoonError): HarpoonError;
+/**
+ * Union type of all API-facing error classes.
+ * Useful for Effect error channel typing.
+ */
+export type HarpoonApiError = NetworkError | ImageError | ContainerError | ScopeError | BindingError;
+export declare const isHarpoonError: (e: unknown) => e is HarpoonError;
+export declare const isNetworkError: (e: unknown) => e is NetworkError;
+export declare const isImageError: (e: unknown) => e is ImageError;
+export declare const isContainerError: (e: unknown) => e is ContainerError;
+export declare const isScopeError: (e: unknown) => e is ScopeError;
+export declare const isBindingError: (e: unknown) => e is BindingError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAkB;IAEvC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAY7D;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,SAAkB,IAAI,EAAE,cAAc,CAAkB;gBAE5C,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAQ1D;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,YAAY;IAC1C,SAAkB,IAAI,EAAE,YAAY,CAAgB;gBAExC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAQzD;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC9C,SAAkB,IAAI,EAAE,gBAAgB,CAAoB;gBAEhD,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAQ1D;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,YAAY;IAC1C,SAAkB,IAAI,EAAE,YAAY,CAAgB;gBAExC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAI3C;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,SAAkB,IAAI,EAAE,cAAc,CAAkB;IAExD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAKhE;AAID;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,OAAO,YAA2B,GAC7C,YAAY,CA4Bd;AAID;;;GAGG;AACH,MAAM,MAAM,eAAe,GACvB,YAAY,GACZ,UAAU,GACV,cAAc,GACd,UAAU,GACV,YAAY,CAAC;AAIjB,eAAO,MAAM,cAAc,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,YACtB,CAAC;AAE5B,eAAO,MAAM,cAAc,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,YACtB,CAAC;AAE5B,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,UACtB,CAAC;AAE1B,eAAO,MAAM,gBAAgB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,cACtB,CAAC;AAE9B,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,UACtB,CAAC;AAE1B,eAAO,MAAM,cAAc,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,YACtB,CAAC"}