@git.zone/tsdocker 1.3.0 → 1.4.0

package/dist_ts/classes.registrystorage.js

@@ -0,0 +1,76 @@
+import * as plugins from './tsdocker.plugins.js';
+import { logger } from './tsdocker.logging.js';
+import { DockerRegistry } from './classes.dockerregistry.js';
+/**
+ * Storage class for managing multiple Docker registries
+ */
+export class RegistryStorage {
+    objectMap = new plugins.lik.ObjectMap();
+    constructor() {
+        // Nothing here
+    }
+    /**
+     * Adds a registry to the storage
+     */
+    addRegistry(registryArg) {
+        this.objectMap.add(registryArg);
+    }
+    /**
+     * Gets a registry by its URL
+     */
+    getRegistryByUrl(registryUrlArg) {
+        return this.objectMap.findSync((registryArg) => {
+            return registryArg.registryUrl === registryUrlArg;
+        });
+    }
+    /**
+     * Gets all registries
+     */
+    getAllRegistries() {
+        return this.objectMap.getArray();
+    }
+    /**
+     * Logs in to all registries
+     */
+    async loginAll() {
+        await this.objectMap.forEach(async (registryArg) => {
+            await registryArg.login();
+        });
+        logger.log('success', 'logged in successfully into all available DockerRegistries!');
+    }
+    /**
+     * Logs out from all registries
+     */
+    async logoutAll() {
+        await this.objectMap.forEach(async (registryArg) => {
+            await registryArg.logout();
+        });
+        logger.log('info', 'logged out from all DockerRegistries');
+    }
+    /**
+     * Loads registries from environment variables
+     * Looks for DOCKER_REGISTRY_1, DOCKER_REGISTRY_2, etc. (pipe-delimited format)
+     * Or individual registries like DOCKER_REGISTRY_GITLAB_URL, etc.
+     */
+    loadFromEnv() {
+        // Check for numbered registry env vars (pipe-delimited format)
+        for (let i = 1; i <= 10; i++) {
+            const envVar = process.env[`DOCKER_REGISTRY_${i}`];
+            if (envVar) {
+                try {
+                    const registry = DockerRegistry.fromEnvString(envVar);
+                    this.addRegistry(registry);
+                }
+                catch (err) {
+                    logger.log('warn', `Failed to parse DOCKER_REGISTRY_${i}: ${err.message}`);
+                }
+            }
+        }
+        // Check for default registry
+        const defaultRegistry = DockerRegistry.fromEnv();
+        if (defaultRegistry) {
+            this.addRegistry(defaultRegistry);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.tsdockermanager.d.ts

@@ -0,0 +1,53 @@
+import { Dockerfile } from './classes.dockerfile.js';
+import { RegistryStorage } from './classes.registrystorage.js';
+import type { ITsDockerConfig } from './interfaces/index.js';
+/**
+ * Main orchestrator class for Docker operations
+ */
+export declare class TsDockerManager {
+    registryStorage: RegistryStorage;
+    config: ITsDockerConfig;
+    projectInfo: any;
+    private dockerfiles;
+    constructor(config: ITsDockerConfig);
+    /**
+     * Prepares the manager by loading project info and registries
+     */
+    prepare(): Promise<void>;
+    /**
+     * Logs in to all configured registries
+     */
+    login(): Promise<void>;
+    /**
+     * Discovers and sorts Dockerfiles in the current directory
+     */
+    discoverDockerfiles(): Promise<Dockerfile[]>;
+    /**
+     * Builds all discovered Dockerfiles in dependency order
+     */
+    build(): Promise<Dockerfile[]>;
+    /**
+     * Ensures Docker buildx is set up for multi-architecture builds
+     */
+    private ensureBuildx;
+    /**
+     * Pushes all built images to specified registries
+     */
+    push(registryUrls?: string[]): Promise<void>;
+    /**
+     * Pulls images from a specified registry
+     */
+    pull(registryUrl: string): Promise<void>;
+    /**
+     * Runs tests for all Dockerfiles
+     */
+    test(): Promise<void>;
+    /**
+     * Lists all discovered Dockerfiles and their info
+     */
+    list(): Promise<Dockerfile[]>;
+    /**
+     * Gets the cached Dockerfiles (after discovery)
+     */
+    getDockerfiles(): Dockerfile[];
+}

package/dist_ts/classes.tsdockermanager.js

@@ -0,0 +1,222 @@
+import * as plugins from './tsdocker.plugins.js';
+import * as paths from './tsdocker.paths.js';
+import { logger } from './tsdocker.logging.js';
+import { Dockerfile } from './classes.dockerfile.js';
+import { DockerRegistry } from './classes.dockerregistry.js';
+import { RegistryStorage } from './classes.registrystorage.js';
+const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+});
+/**
+ * Main orchestrator class for Docker operations
+ */
+export class TsDockerManager {
+    registryStorage;
+    config;
+    projectInfo;
+    dockerfiles = [];
+    constructor(config) {
+        this.config = config;
+        this.registryStorage = new RegistryStorage();
+    }
+    /**
+     * Prepares the manager by loading project info and registries
+     */
+    async prepare() {
+        // Load project info
+        try {
+            const projectinfoInstance = new plugins.projectinfo.ProjectInfo(paths.cwd);
+            this.projectInfo = {
+                npm: {
+                    name: projectinfoInstance.npm.name,
+                    version: projectinfoInstance.npm.version,
+                },
+            };
+        }
+        catch (err) {
+            logger.log('warn', 'Could not load project info');
+            this.projectInfo = null;
+        }
+        // Load registries from environment
+        this.registryStorage.loadFromEnv();
+        // Add registries from config if specified
+        if (this.config.registries) {
+            for (const registryUrl of this.config.registries) {
+                // Check if already loaded from env
+                if (!this.registryStorage.getRegistryByUrl(registryUrl)) {
+                    // Try to load credentials for this registry from env
+                    const envVarName = registryUrl.replace(/\./g, '_').toUpperCase();
+                    const envString = process.env[`DOCKER_REGISTRY_${envVarName}`];
+                    if (envString) {
+                        try {
+                            const registry = DockerRegistry.fromEnvString(envString);
+                            this.registryStorage.addRegistry(registry);
+                        }
+                        catch (err) {
+                            logger.log('warn', `Could not load credentials for registry ${registryUrl}`);
+                        }
+                    }
+                }
+            }
+        }
+        logger.log('info', `Prepared TsDockerManager with ${this.registryStorage.getAllRegistries().length} registries`);
+    }
+    /**
+     * Logs in to all configured registries
+     */
+    async login() {
+        if (this.registryStorage.getAllRegistries().length === 0) {
+            logger.log('warn', 'No registries configured');
+            return;
+        }
+        await this.registryStorage.loginAll();
+    }
+    /**
+     * Discovers and sorts Dockerfiles in the current directory
+     */
+    async discoverDockerfiles() {
+        this.dockerfiles = await Dockerfile.readDockerfiles(this);
+        this.dockerfiles = await Dockerfile.sortDockerfiles(this.dockerfiles);
+        this.dockerfiles = await Dockerfile.mapDockerfiles(this.dockerfiles);
+        return this.dockerfiles;
+    }
+    /**
+     * Builds all discovered Dockerfiles in dependency order
+     */
+    async build() {
+        if (this.dockerfiles.length === 0) {
+            await this.discoverDockerfiles();
+        }
+        if (this.dockerfiles.length === 0) {
+            logger.log('warn', 'No Dockerfiles found');
+            return [];
+        }
+        // Check if buildx is needed
+        if (this.config.platforms && this.config.platforms.length > 1) {
+            await this.ensureBuildx();
+        }
+        logger.log('info', `Building ${this.dockerfiles.length} Dockerfiles...`);
+        await Dockerfile.buildDockerfiles(this.dockerfiles);
+        logger.log('success', 'All Dockerfiles built successfully');
+        return this.dockerfiles;
+    }
+    /**
+     * Ensures Docker buildx is set up for multi-architecture builds
+     */
+    async ensureBuildx() {
+        logger.log('info', 'Setting up Docker buildx for multi-platform builds...');
+        // Check if a buildx builder exists
+        const inspectResult = await smartshellInstance.exec('docker buildx inspect tsdocker-builder 2>/dev/null');
+        if (inspectResult.exitCode !== 0) {
+            // Create a new buildx builder
+            logger.log('info', 'Creating new buildx builder...');
+            await smartshellInstance.exec('docker buildx create --name tsdocker-builder --use');
+            await smartshellInstance.exec('docker buildx inspect --bootstrap');
+        }
+        else {
+            // Use existing builder
+            await smartshellInstance.exec('docker buildx use tsdocker-builder');
+        }
+        logger.log('ok', 'Docker buildx ready');
+    }
+    /**
+     * Pushes all built images to specified registries
+     */
+    async push(registryUrls) {
+        if (this.dockerfiles.length === 0) {
+            await this.discoverDockerfiles();
+        }
+        if (this.dockerfiles.length === 0) {
+            logger.log('warn', 'No Dockerfiles found to push');
+            return;
+        }
+        // Determine which registries to push to
+        let registriesToPush = [];
+        if (registryUrls && registryUrls.length > 0) {
+            // Push to specified registries
+            for (const url of registryUrls) {
+                const registry = this.registryStorage.getRegistryByUrl(url);
+                if (registry) {
+                    registriesToPush.push(registry);
+                }
+                else {
+                    logger.log('warn', `Registry ${url} not found in storage`);
+                }
+            }
+        }
+        else {
+            // Push to all configured registries
+            registriesToPush = this.registryStorage.getAllRegistries();
+        }
+        if (registriesToPush.length === 0) {
+            logger.log('warn', 'No registries available to push to');
+            return;
+        }
+        // Push each Dockerfile to each registry
+        for (const dockerfile of this.dockerfiles) {
+            for (const registry of registriesToPush) {
+                await dockerfile.push(registry);
+            }
+        }
+        logger.log('success', 'All images pushed successfully');
+    }
+    /**
+     * Pulls images from a specified registry
+     */
+    async pull(registryUrl) {
+        if (this.dockerfiles.length === 0) {
+            await this.discoverDockerfiles();
+        }
+        const registry = this.registryStorage.getRegistryByUrl(registryUrl);
+        if (!registry) {
+            throw new Error(`Registry ${registryUrl} not found`);
+        }
+        for (const dockerfile of this.dockerfiles) {
+            await dockerfile.pull(registry);
+        }
+        logger.log('success', 'All images pulled successfully');
+    }
+    /**
+     * Runs tests for all Dockerfiles
+     */
+    async test() {
+        if (this.dockerfiles.length === 0) {
+            await this.discoverDockerfiles();
+        }
+        if (this.dockerfiles.length === 0) {
+            logger.log('warn', 'No Dockerfiles found to test');
+            return;
+        }
+        await Dockerfile.testDockerfiles(this.dockerfiles);
+        logger.log('success', 'All tests completed');
+    }
+    /**
+     * Lists all discovered Dockerfiles and their info
+     */
+    async list() {
+        if (this.dockerfiles.length === 0) {
+            await this.discoverDockerfiles();
+        }
+        console.log('\nDiscovered Dockerfiles:');
+        console.log('========================\n');
+        for (let i = 0; i < this.dockerfiles.length; i++) {
+            const df = this.dockerfiles[i];
+            console.log(`${i + 1}. ${df.filePath}`);
+            console.log(`   Tag: ${df.cleanTag}`);
+            console.log(`   Base Image: ${df.baseImage}`);
+            console.log(`   Version: ${df.version}`);
+            if (df.localBaseImageDependent) {
+                console.log(`   Depends on: ${df.localBaseDockerfile?.cleanTag}`);
+            }
+            console.log('');
+        }
+        return this.dockerfiles;
+    }
+    /**
+     * Gets the cached Dockerfiles (after discovery)
+     */
+    getDockerfiles() {
+        return this.dockerfiles;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tsdockermanager.js","sourceRoot":"","sources":["../ts/classes.tsdockermanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/interfaces/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Configuration interface for tsdocker
+ * Extends legacy config with new Docker build capabilities
+ */
+export interface ITsDockerConfig {
+    baseImage: string;
+    command: string;
+    dockerSock: boolean;
+    keyValueObject: {
+        [key: string]: any;
+    };
+    registries?: string[];
+    registryRepoMap?: {
+        [registry: string]: string;
+    };
+    buildArgEnvMap?: {
+        [dockerArg: string]: string;
+    };
+    platforms?: string[];
+    push?: boolean;
+    testDir?: string;
+}
+/**
+ * Options for constructing a DockerRegistry
+ */
+export interface IDockerRegistryOptions {
+    registryUrl: string;
+    username: string;
+    password: string;
+}
+/**
+ * Information about a discovered Dockerfile
+ */
+export interface IDockerfileInfo {
+    filePath: string;
+    fileName: string;
+    version: string;
+    baseImage: string;
+    buildTag: string;
+    localBaseImageDependent: boolean;
+}
+/**
+ * Options for creating a Dockerfile instance
+ */
+export interface IDockerfileOptions {
+    filePath?: string;
+    fileContents?: string;
+    read?: boolean;
+}
+/**
+ * Result from a Docker build operation
+ */
+export interface IBuildResult {
+    success: boolean;
+    tag: string;
+    duration?: number;
+    error?: string;
+}
+/**
+ * Result from a Docker push operation
+ */
+export interface IPushResult {
+    success: boolean;
+    registry: string;
+    tag: string;
+    digest?: string;
+    error?: string;
+}

package/dist_ts/interfaces/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/tsdocker.cli.js

@@ -4,8 +4,10 @@ import * as paths from './tsdocker.paths.js';
 import * as ConfigModule from './tsdocker.config.js';
 import * as DockerModule from './tsdocker.docker.js';
 import { logger, ora } from './tsdocker.logging.js';
+import { TsDockerManager } from './classes.tsdockermanager.js';
 const tsdockerCli = new plugins.smartcli.Smartcli();
 export let run = () => {
+    // Default command: run tests in container (legacy behavior)
     tsdockerCli.standardCommand().subscribe(async (argvArg) => {
         const configArg = await ConfigModule.run().then(DockerModule.run);
         if (configArg.exitCode === 0) {
@@ -16,6 +18,118 @@ export let run = () => {
             process.exit(1);
         }
     });
+    /**
+     * Build all Dockerfiles in dependency order
+     */
+    tsdockerCli.addCommand('build').subscribe(async (argvArg) => {
+        try {
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            await manager.build();
+            logger.log('success', 'Build completed successfully');
+        }
+        catch (err) {
+            logger.log('error', `Build failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * Push built images to configured registries
+     */
+    tsdockerCli.addCommand('push').subscribe(async (argvArg) => {
+        try {
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            // Login first
+            await manager.login();
+            // Build images first (if not already built)
+            await manager.build();
+            // Get registry from arguments if specified
+            const registryArg = argvArg._[1]; // e.g., tsdocker push registry.gitlab.com
+            const registries = registryArg ? [registryArg] : undefined;
+            await manager.push(registries);
+            logger.log('success', 'Push completed successfully');
+        }
+        catch (err) {
+            logger.log('error', `Push failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * Pull images from a specified registry
+     */
+    tsdockerCli.addCommand('pull').subscribe(async (argvArg) => {
+        try {
+            const registryArg = argvArg._[1]; // e.g., tsdocker pull registry.gitlab.com
+            if (!registryArg) {
+                logger.log('error', 'Registry URL required. Usage: tsdocker pull <registry-url>');
+                process.exit(1);
+            }
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            // Login first
+            await manager.login();
+            await manager.pull(registryArg);
+            logger.log('success', 'Pull completed successfully');
+        }
+        catch (err) {
+            logger.log('error', `Pull failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * Run container tests for all Dockerfiles
+     */
+    tsdockerCli.addCommand('test').subscribe(async (argvArg) => {
+        try {
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            // Build images first
+            await manager.build();
+            // Run tests
+            await manager.test();
+            logger.log('success', 'Tests completed successfully');
+        }
+        catch (err) {
+            logger.log('error', `Tests failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * Login to configured registries
+     */
+    tsdockerCli.addCommand('login').subscribe(async (argvArg) => {
+        try {
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            await manager.login();
+            logger.log('success', 'Login completed successfully');
+        }
+        catch (err) {
+            logger.log('error', `Login failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * List discovered Dockerfiles and their dependencies
+     */
+    tsdockerCli.addCommand('list').subscribe(async (argvArg) => {
+        try {
+            const config = await ConfigModule.run();
+            const manager = new TsDockerManager(config);
+            await manager.prepare();
+            await manager.list();
+        }
+        catch (err) {
+            logger.log('error', `List failed: ${err.message}`);
+            process.exit(1);
+        }
+    });
     /**
      * this command is executed inside docker and meant for use from outside docker
      */
@@ -52,13 +166,6 @@ export let run = () => {
         }
         ora.finishSuccess('docker environment now is clean!');
     });
-    tsdockerCli.addCommand('speedtest').subscribe(async (argvArg) => {
-        const smartshellInstance = new plugins.smartshell.Smartshell({
-            executor: 'bash'
-        });
-        logger.log('ok', 'Starting speedtest');
-        await smartshellInstance.exec(`docker pull tianon/speedtest && docker run --rm tianon/speedtest --accept-license --accept-gdpr`);
-    });
     tsdockerCli.addCommand('vscode').subscribe(async (argvArg) => {
         const smartshellInstance = new plugins.smartshell.Smartshell({
             executor: 'bash'
@@ -69,4 +176,4 @@ export let run = () => {
     });
     tsdockerCli.startParse();
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tsdocker.cli.js","sourceRoot":"","sources":["../ts/tsdocker.cli.ts"],"names":[],"mappings":"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"}

package/dist_ts/tsdocker.config.d.ts

@@ -1,10 +1,5 @@
-export interface IConfig {
-    baseImage: string;
-    command: string;
-    dockerSock: boolean;
+import type { ITsDockerConfig } from './interfaces/index.js';
+export type IConfig = ITsDockerConfig & {
     exitCode?: number;
-    keyValueObject: {
-        [key: string]: any;
-    };
-}
+};
 export declare let run: () => Promise<IConfig>;

package/dist_ts/tsdocker.config.js

@@ -14,11 +14,19 @@ const getQenvKeyValueObject = async () => {
 const buildConfig = async (qenvKeyValueObjectArg) => {
     const npmextra = new plugins.npmextra.Npmextra(paths.cwd);
     const config = npmextra.dataFor('@git.zone/tsdocker', {
+        // Legacy options (backward compatible)
         baseImage: 'hosttoday/ht-docker-node:npmdocker',
         init: 'rm -rf node_nodules/ && yarn install',
         command: 'npmci npm test',
         dockerSock: false,
-        keyValueObject: qenvKeyValueObjectArg
+        keyValueObject: qenvKeyValueObjectArg,
+        // New Docker build options
+        registries: [],
+        registryRepoMap: {},
+        buildArgEnvMap: {},
+        platforms: ['linux/amd64'],
+        push: false,
+        testDir: undefined,
     });
     return config;
 };
@@ -26,4 +34,4 @@ export let run = async () => {
     const config = await getQenvKeyValueObject().then(buildConfig);
     return config;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNkb2NrZXIuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHNkb2NrZXIuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sdUJBQXVCLENBQUM7QUFDakQsT0FBTyxLQUFLLEtBQUssTUFBTSxxQkFBcUIsQ0FBQztBQUM3QyxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQVV6QixNQUFNLHFCQUFxQixHQUFHLEtBQUssSUFBSSxFQUFFO0lBQ3ZDLElBQUksdUJBQTJELENBQUM7SUFDaEUsSUFBSSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsVUFBVSxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzVELHVCQUF1QixHQUFHLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxTQUFTLENBQUMsQ0FBQyxjQUFjLENBQUM7SUFDdkYsQ0FBQztTQUFNLENBQUM7UUFDTix1QkFBdUIsR0FBRyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUNELE9BQU8sdUJBQXVCLENBQUM7QUFDakMsQ0FBQyxDQUFDO0FBRUYsTUFBTSxXQUFXLEdBQUcsS0FBSyxFQUFFLHFCQUF5RCxFQUFFLEVBQUU7SUFDdEYsTUFBTSxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDMUQsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBVSxvQkFBb0IsRUFBRTtRQUM3RCxTQUFTLEVBQUUsb0NBQW9DO1FBQy9DLElBQUksRUFBRSxzQ0FBc0M7UUFDNUMsT0FBTyxFQUFFLGdCQUFnQjtRQUN6QixVQUFVLEVBQUUsS0FBSztRQUNqQixjQUFjLEVBQUUscUJBQXFCO0tBQ3RDLENBQUMsQ0FBQztJQUNILE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxJQUFJLEdBQUcsR0FBRyxLQUFLLElBQXNCLEVBQUU7SUFDNUMsTUFBTSxNQUFNLEdBQUcsTUFBTSxxQkFBcUIsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUMvRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNkb2NrZXIuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHNkb2NrZXIuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sdUJBQXVCLENBQUM7QUFDakQsT0FBTyxLQUFLLEtBQUssTUFBTSxxQkFBcUIsQ0FBQztBQUM3QyxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQVF6QixNQUFNLHFCQUFxQixHQUFHLEtBQUssSUFBSSxFQUFFO0lBQ3ZDLElBQUksdUJBQTJELENBQUM7SUFDaEUsSUFBSSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsVUFBVSxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzVELHVCQUF1QixHQUFHLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxTQUFTLENBQUMsQ0FBQyxjQUFjLENBQUM7SUFDdkYsQ0FBQztTQUFNLENBQUM7UUFDTix1QkFBdUIsR0FBRyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUNELE9BQU8sdUJBQXVCLENBQUM7QUFDakMsQ0FBQyxDQUFDO0FBRUYsTUFBTSxXQUFXLEdBQUcsS0FBSyxFQUFFLHFCQUF5RCxFQUFFLEVBQUU7SUFDdEYsTUFBTSxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDMUQsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBVSxvQkFBb0IsRUFBRTtRQUM3RCx1Q0FBdUM7UUFDdkMsU0FBUyxFQUFFLG9DQUFvQztRQUMvQyxJQUFJLEVBQUUsc0NBQXNDO1FBQzVDLE9BQU8sRUFBRSxnQkFBZ0I7UUFDekIsVUFBVSxFQUFFLEtBQUs7UUFDakIsY0FBYyxFQUFFLHFCQUFxQjtRQUVyQywyQkFBMkI7UUFDM0IsVUFBVSxFQUFFLEVBQUU7UUFDZCxlQUFlLEVBQUUsRUFBRTtRQUNuQixjQUFjLEVBQUUsRUFBRTtRQUNsQixTQUFTLEVBQUUsQ0FBQyxhQUFhLENBQUM7UUFDMUIsSUFBSSxFQUFFLEtBQUs7UUFDWCxPQUFPLEVBQUUsU0FBUztLQUNuQixDQUFDLENBQUM7SUFDSCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsSUFBSSxHQUFHLEdBQUcsS0FBSyxJQUFzQixFQUFFO0lBQzVDLE1BQU0sTUFBTSxHQUFHLE1BQU0scUJBQXFCLEVBQUUsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDL0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyxDQUFDIn0=