@datatruck/cli 0.0.1

package/lib/Action/RestoreAction.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreAction = void 0;
+const AppError_1 = require("../Error/AppError");
+const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
+const TaskFactory_1 = require("../Factory/TaskFactory");
+const cli_util_1 = require("../util/cli-util");
+const config_util_1 = require("../util/datatruck/config-util");
+const fs_util_1 = require("../util/fs-util");
+const object_util_1 = require("../util/object-util");
+const process_util_1 = require("../util/process-util");
+const assert_1 = require("assert");
+const os_1 = require("os");
+class RestoreAction {
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+        this.taskErrors = {};
+        this.repoErrors = {};
+    }
+    assocConfigs(packages, snapshots) {
+        return snapshots.map((snapshot) => {
+            const pkg = packages.find((pkg) => pkg.name === snapshot.packageName) ?? null;
+            return [snapshot, pkg];
+        });
+    }
+    async init(session, snapshotId, snapshots) {
+        await session.initDrivers();
+        for (const [, pkg] of snapshots) {
+            (0, assert_1.ok)(pkg);
+            const sessionId = await session.init({
+                snapshotId: snapshotId,
+                packageName: pkg.name,
+            });
+            if (pkg.task)
+                await session.initTask({
+                    sessionId: sessionId,
+                    taskName: pkg.task.name,
+                });
+            for (const repositoryName of pkg.repositoryNames ?? []) {
+                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repositoryName);
+                await session.initRepository({
+                    sessionId: sessionId,
+                    repositoryName: repositoryName,
+                    repositoryType: repo.type,
+                });
+            }
+        }
+    }
+    async findSnapshots() {
+        const result = [];
+        for (const repository of this.config.repositories) {
+            if (this.options.repositoryNames &&
+                !this.options.repositoryNames.includes(repository.name))
+                continue;
+            if (this.options.repositoryTypes &&
+                !this.options.repositoryTypes.includes(repository.type))
+                continue;
+            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repository);
+            const snapshots = await repoInstance.onSnapshots({
+                options: {
+                    packageNames: this.options.packageNames,
+                    ids: [this.options.snapshotId],
+                    tags: this.options.tags,
+                },
+            });
+            result.push(...snapshots.map((snapshot) => ({
+                ...snapshot,
+                repositoryName: repository.name,
+            })));
+        }
+        return result;
+    }
+    groupSnapshots(snapshots) {
+        const names = [];
+        return snapshots.filter((snapshot) => {
+            if (names.includes(snapshot.packageName))
+                return false;
+            names.push(snapshot.packageName);
+            return true;
+        });
+    }
+    async execTask(session, pkg, task, snapshot, targetPath) {
+        const taskId = session.findTaskId({
+            packageName: pkg.name,
+            taskName: task.name,
+        });
+        await session.startTask({
+            id: taskId,
+        });
+        let error;
+        if (this.repoErrors[pkg.name]?.length) {
+            error = new AppError_1.AppError("Repository failed");
+        }
+        else if (this.taskErrors[pkg.name]?.length) {
+            error = new AppError_1.AppError("Previous task failed");
+        }
+        else {
+            try {
+                const taskInstance = (0, TaskFactory_1.TaskFactory)(task);
+                await taskInstance.onRestore({
+                    package: pkg,
+                    options: this.options,
+                    snapshot,
+                    targetPath,
+                    onProgress: async (data) => {
+                        await session.progressTask({
+                            id: taskId,
+                            progressCurrent: data.current,
+                            progressPercent: data.percent,
+                            progressStep: data.step,
+                            progressStepPercent: data.stepPercent,
+                            progressTotal: data.total,
+                        });
+                    },
+                });
+            }
+            catch (_) {
+                if (!this.taskErrors[pkg.name])
+                    this.taskErrors[pkg.name] = [];
+                this.taskErrors[pkg.name].push((error = _));
+            }
+        }
+        await session.endTask({
+            id: taskId,
+            error: error?.stack,
+        });
+        return error ? false : true;
+    }
+    async execRepository(session, pkg, repo, snapshot, targetPath) {
+        const repositoryId = session.findRepositoryId({
+            packageName: pkg.name,
+            repositoryName: repo.name,
+        });
+        await session.startRepository({
+            id: repositoryId,
+        });
+        let repoError;
+        try {
+            if (typeof pkg.restorePath !== "string")
+                throw new AppError_1.AppError("Restore path is not defined");
+            await (0, fs_util_1.mkdirIfNotExists)(pkg.restorePath);
+            if (!(await (0, fs_util_1.isDirEmpty)(pkg.restorePath)))
+                throw new AppError_1.AppError(`Restore path is not empty: ${pkg.restorePath}`);
+            if (this.options.verbose)
+                (0, cli_util_1.logExec)(`restorePath=${pkg.restorePath}`);
+            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+            await repoInstance.onRestore({
+                package: pkg,
+                targetPath,
+                packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repo.type &&
+                    (!config.names || config.names.includes(repo.name)))?.config,
+                options: this.options,
+                snapshot: snapshot,
+                onProgress: async (data) => {
+                    await session.progressRepository({
+                        id: repositoryId,
+                        progressCurrent: data.current,
+                        progressPercent: data.percent,
+                        progressStep: data.step,
+                        progressStepPercent: data.stepPercent,
+                        progressTotal: data.total,
+                    });
+                },
+            });
+            if (pkg.restorePermissions && (0, os_1.platform)() !== "win32")
+                await (0, process_util_1.exec)("chown", [
+                    "-R",
+                    `${pkg.restorePermissions.uid}:${pkg.restorePermissions.gid}`,
+                    pkg.restorePath,
+                ], {}, {
+                    log: this.options.verbose,
+                });
+        }
+        catch (error) {
+            (0, object_util_1.push)(this.repoErrors, pkg.name, (repoError = error));
+        }
+        await session.endRepository({
+            id: repositoryId,
+            error: repoError?.stack,
+        });
+        return repoError ? false : true;
+    }
+    getError(pkg) {
+        const taskErrors = this.taskErrors[pkg.name]?.length;
+        const repoErrors = this.repoErrors[pkg.name]?.length;
+        if (taskErrors && repoErrors) {
+            return new AppError_1.AppError("Task and repository failed");
+        }
+        else if (taskErrors && !repoErrors) {
+            return new AppError_1.AppError("Task failed");
+        }
+        else if (!taskErrors && repoErrors) {
+            return new AppError_1.AppError("Repository failed");
+        }
+        else {
+            return null;
+        }
+    }
+    async exec(session) {
+        if (!this.options.snapshotId)
+            throw new AppError_1.AppError("Snapshot id is required");
+        const snapshots = this.groupSnapshots(await this.findSnapshots());
+        if (!snapshots.length)
+            throw new AppError_1.AppError("None snapshot found");
+        let packages = (0, config_util_1.filterPackages)(this.config, this.options);
+        packages = (0, config_util_1.resolvePackages)(packages, {
+            snapshotId: this.options.snapshotId,
+            action: "restore",
+        });
+        const snapshotAndConfigs = this.assocConfigs(packages, snapshots);
+        await this.init(session, this.options.snapshotId, snapshotAndConfigs);
+        let sessionErrors = 0;
+        for (const [snapshot, pkg] of snapshotAndConfigs) {
+            (0, assert_1.ok)(pkg);
+            const repo = (0, config_util_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
+            const id = session.findId({
+                packageName: pkg.name,
+            });
+            await session.start({ id });
+            let targetPath;
+            if (pkg.task) {
+                const taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
+                const result = await taskInstance.onBeforeRestore({
+                    options: this.options,
+                    package: pkg,
+                    snapshot,
+                });
+                targetPath = result?.targetPath;
+            }
+            await this.execRepository(session, pkg, repo, snapshot, targetPath);
+            if (pkg.task)
+                await this.execTask(session, pkg, pkg.task, snapshot, targetPath);
+            const error = this.getError(pkg);
+            await session.end({
+                id,
+                error: error?.message,
+            });
+            if (error)
+                sessionErrors++;
+        }
+        await session.endDrivers();
+        return !sessionErrors;
+    }
+}
+exports.RestoreAction = RestoreAction;

package/lib/Action/RestoreSessionsAction.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigType } from "../Config/Config";
+import { ReadDataType } from "../SessionDriver/SessionDriverAbstract";
+import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
+import { IfRequireKeys } from "../util/ts-util";
+export declare type RestoreSessionsActionOptionsType = ReadDataType & {
+    verbose?: boolean;
+};
+export declare class RestoreSessionsAction<TRequired extends boolean = true> {
+    readonly config: ConfigType;
+    readonly options: IfRequireKeys<TRequired, RestoreSessionsActionOptionsType>;
+    constructor(config: ConfigType, options: IfRequireKeys<TRequired, RestoreSessionsActionOptionsType>);
+    exec(manager: RestoreSessionManager): Promise<import("../SessionDriver/SessionDriverAbstract").ReadResultType[]>;
+}

package/lib/Action/RestoreSessionsAction.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreSessionsAction = void 0;
+class RestoreSessionsAction {
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+    }
+    async exec(manager) {
+        await manager.initDrivers();
+        const result = await manager.readAll(this.options);
+        await manager.endDrivers();
+        return result;
+    }
+}
+exports.RestoreSessionsAction = RestoreSessionsAction;

package/lib/Action/SnapshotsAction.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigType } from "../Config/Config";
+import { SnapshotResultType } from "../Repository/RepositoryAbstract";
+import { IfRequireKeys } from "../util/ts-util";
+export declare type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
+export declare type SnapshotsActionOptionsType = {
+    ids?: string[];
+    repositoryNames?: string[];
+    packageNames?: string[];
+    repositoryTypes?: string[];
+    verbose?: boolean;
+    tags?: string[];
+    last?: number;
+    lastMinutely?: number;
+    lastHourly?: number;
+    lastDaily?: number;
+    lastWeekly?: number;
+    lastMonthly?: number;
+    lastYearly?: number;
+    groupBy?: SnapshotGroupByType[];
+};
+export declare type SnapshotExtendedType = {
+    repositoryName: string;
+    repositoryType: string;
+} & SnapshotResultType;
+export declare class SnapshotsAction<TRequired extends boolean = true> {
+    readonly config: ConfigType;
+    readonly options: IfRequireKeys<TRequired, SnapshotsActionOptionsType>;
+    constructor(config: ConfigType, options: IfRequireKeys<TRequired, SnapshotsActionOptionsType>);
+    exec(): Promise<SnapshotExtendedType[]>;
+}

package/lib/Action/SnapshotsAction.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotsAction = void 0;
+const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
+const snapshot_util_1 = require("../util/datatruck/snapshot-util");
+class SnapshotsAction {
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+    }
+    async exec() {
+        let result = [];
+        for (const repo of this.config.repositories) {
+            if (this.options.repositoryNames &&
+                !this.options.repositoryNames.includes(repo.name))
+                continue;
+            if (this.options.repositoryTypes &&
+                !this.options.repositoryTypes.includes(repo.type))
+                continue;
+            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+            const snapshots = await repoInstance.onSnapshots({
+                options: this.options,
+            });
+            const extentedItems = snapshots.map((item) => ({
+                ...item,
+                repositoryName: repo.name,
+                repositoryType: repo.type,
+            }));
+            result.push(...extentedItems);
+        }
+        result = result.sort((a, b) => b.date.localeCompare(a.date));
+        return (0, snapshot_util_1.groupAndFilter)(result, this.options.groupBy, this.options);
+    }
+}
+exports.SnapshotsAction = SnapshotsAction;

package/lib/Command/BackupCommand.d.ts

@@ -0,0 +1,15 @@
+import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { If } from "../util/ts-util";
+import { CommandAbstract } from "./CommandAbstract";
+export declare type BackupCommandOptionsType<TResolved = false> = {
+    package?: If<TResolved, string[]>;
+    repository?: If<TResolved, string[]>;
+    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+    tag?: If<TResolved, string[]>;
+    dryRun?: boolean;
+    date?: string;
+};
+export declare class BackupCommand extends CommandAbstract<BackupCommandOptionsType<false>, BackupCommandOptionsType<true>> {
+    onOptions(): import("../util/cli-util").OptionsType<BackupCommandOptionsType<false>, BackupCommandOptionsType<true>>;
+    onExec(): Promise<0 | 1>;
+}

package/lib/Command/BackupCommand.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupCommand = void 0;
+const BackupAction_1 = require("../Action/BackupAction");
+const ConfigAction_1 = require("../Action/ConfigAction");
+const AppError_1 = require("../Error/AppError");
+const ConsoleSessionDriver_1 = require("../SessionDriver/ConsoleSessionDriver");
+const SqliteSessionDriver_1 = require("../SessionDriver/SqliteSessionDriver");
+const BackupSessionManager_1 = require("../SessionManager/BackupSessionManager");
+const string_util_1 = require("../util/string-util");
+const CommandAbstract_1 = require("./CommandAbstract");
+class BackupCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({
+            dryRun: {
+                description: "Skip execution",
+                option: "--dryRun",
+            },
+            package: {
+                description: "Package names",
+                option: "-p,--package <values>",
+                parser: string_util_1.parseStringList,
+            },
+            repository: {
+                description: "Repository names",
+                option: "-r,--repository <values>",
+                parser: string_util_1.parseStringList,
+            },
+            repositoryType: {
+                description: "Repository types",
+                option: "-t,--repository-type <values>",
+                parser: (v) => (0, string_util_1.parseStringList)(v),
+            },
+            tag: {
+                description: "Tags",
+                option: "--tag <values>",
+                parser: string_util_1.parseStringList,
+            },
+            date: {
+                description: "Date time (ISO)",
+                option: "--date <value>",
+            },
+        });
+    }
+    async onExec() {
+        const verbose = this.globalOptions.verbose ?? 0;
+        const configAction = new ConfigAction_1.ConfigAction({
+            path: this.globalOptions.config,
+            verbose: verbose > 0,
+        });
+        const config = await configAction.exec();
+        const backup = new BackupAction_1.BackupAction(config, {
+            packageNames: this.options.package,
+            repositoryNames: this.options.repository,
+            repositoryTypes: this.options.repositoryType,
+            tags: this.options.tag,
+            dryRun: this.options.dryRun,
+            verbose: verbose > 0,
+            date: this.options.date,
+        });
+        const sessionManager = new BackupSessionManager_1.BackupSessionManager({
+            driver: new SqliteSessionDriver_1.SqliteSessionDriver({
+                verbose: verbose > 1,
+            }),
+            altDrivers: [
+                new ConsoleSessionDriver_1.ConsoleSessionDriver({
+                    verbose: verbose > 0,
+                }),
+            ],
+        });
+        const result = await backup.exec(sessionManager);
+        if (result.errors) {
+            return 1;
+        }
+        else if (!result.total) {
+            throw new AppError_1.AppError("None package config found");
+        }
+        else {
+            return 0;
+        }
+    }
+}
+exports.BackupCommand = BackupCommand;

package/lib/Command/BackupSessionsCommand.d.ts

@@ -0,0 +1,12 @@
+import { If } from "../util/ts-util";
+import { CommandAbstract } from "./CommandAbstract";
+export declare type BackupSessionsCommandOptionsType<TResolved = false> = {
+    package?: If<TResolved, string[]>;
+    repository?: If<TResolved, string[]>;
+    tag?: If<TResolved, string[]>;
+    limit?: number;
+};
+export declare class BackupSessionsCommand extends CommandAbstract<BackupSessionsCommandOptionsType<false>, BackupSessionsCommandOptionsType<true>> {
+    onOptions(): import("../util/cli-util").OptionsType<BackupSessionsCommandOptionsType<false>, BackupSessionsCommandOptionsType<true>>;
+    onExec(): Promise<number>;
+}

package/lib/Command/BackupSessionsCommand.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupSessionsCommand = void 0;
+const BackupSessionsAction_1 = require("../Action/BackupSessionsAction");
+const ConfigAction_1 = require("../Action/ConfigAction");
+const SqliteSessionDriver_1 = require("../SessionDriver/SqliteSessionDriver");
+const BackupSessionManager_1 = require("../SessionManager/BackupSessionManager");
+const DataFormat_1 = require("../util/DataFormat");
+const cli_util_1 = require("../util/cli-util");
+const string_util_1 = require("../util/string-util");
+const CommandAbstract_1 = require("./CommandAbstract");
+class BackupSessionsCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({
+            package: {
+                description: "Package names",
+                option: "-p,--package <values>",
+                parser: string_util_1.parseStringList,
+            },
+            repository: {
+                description: "Repository names",
+                option: "-r,--repository <values>",
+                parser: string_util_1.parseStringList,
+            },
+            tag: {
+                description: "Tags",
+                option: "--tag <values>",
+                parser: string_util_1.parseStringList,
+            },
+            limit: {
+                description: "Limit",
+                option: "-l,--limit <value>",
+                defaults: 10,
+                parser: Number,
+            },
+        });
+    }
+    async onExec() {
+        const verbose = this.globalOptions.verbose ?? 0;
+        const configAction = new ConfigAction_1.ConfigAction({
+            path: this.globalOptions.config,
+            verbose: verbose > 0,
+        });
+        const config = await configAction.exec();
+        const action = new BackupSessionsAction_1.BackupSessionsAction(config, {
+            packageNames: this.options.package,
+            repositoryNames: this.options.repository,
+            tags: this.options.tag,
+            limit: this.options.limit,
+            verbose: verbose > 0,
+        });
+        const manager = new BackupSessionManager_1.BackupSessionManager({
+            driver: new SqliteSessionDriver_1.SqliteSessionDriver({
+                verbose: verbose > 1,
+            }),
+            verbose: verbose > 1,
+        });
+        const dataFormat = new DataFormat_1.DataFormat({
+            items: await action.exec(manager),
+            table: {
+                labels: [
+                    "   ",
+                    "Id.",
+                    "Snapshot id.",
+                    "Date",
+                    "Repository",
+                    "Repository type",
+                    "Package",
+                    "",
+                ],
+                handler: (item) => [
+                    (0, cli_util_1.resultColumn)(item.error, item.state),
+                    item.id,
+                    item.snapshotId.slice(0, 8),
+                    (0, string_util_1.formatDateTime)(item.creationDate),
+                    item.repositoryName,
+                    item.repositoryType,
+                    item.packageName,
+                    (0, cli_util_1.errorColumn)(item.error, verbose),
+                ],
+            },
+        });
+        if (this.globalOptions.outputFormat)
+            console.log(dataFormat.format(this.globalOptions.outputFormat));
+        return 0;
+    }
+}
+exports.BackupSessionsCommand = BackupSessionsCommand;

package/lib/Command/CleanCacheCommand.d.ts

@@ -0,0 +1,6 @@
+import { CommandAbstract } from "./CommandAbstract";
+export declare type CleanCacheCommandOptionsType<TResolved = false> = {};
+export declare class CleanCacheCommand extends CommandAbstract<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>> {
+    onOptions(): import("../util/cli-util").OptionsType<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>>;
+    onExec(): Promise<number>;
+}

package/lib/Command/CleanCacheCommand.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanCacheCommand = void 0;
+const CleanCacheAction_1 = require("../Action/CleanCacheAction");
+const fs_util_1 = require("../util/fs-util");
+const CommandAbstract_1 = require("./CommandAbstract");
+class CleanCacheCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({});
+    }
+    async onExec() {
+        const action = new CleanCacheAction_1.CleanCacheAction({
+            verbose: !!this.globalOptions.verbose,
+        });
+        console.info(`Cleaning ${(0, fs_util_1.parentTmpDir)()}...`);
+        await action.exec();
+        return 0;
+    }
+}
+exports.CleanCacheCommand = CleanCacheCommand;

package/lib/Command/CommandAbstract.d.ts

@@ -0,0 +1,19 @@
+import { FormatType } from "../util/DataFormat";
+import { OptionsType } from "../util/cli-util";
+import { SimilarObject } from "../util/ts-util";
+export declare type GlobalOptionsType<TResolved = false> = {
+    config: string;
+    outputFormat?: FormatType;
+    verbose?: number;
+};
+export declare type CommandConstructorType<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
+    new (globalOptions: GlobalOptionsType<true>, options: TOptions): CommandAbstract<TUnresolvedOptions, TOptions>;
+};
+export declare abstract class CommandAbstract<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> {
+    readonly globalOptions: GlobalOptionsType<true>;
+    readonly options: TOptions;
+    constructor(globalOptions: GlobalOptionsType<true>, options: TUnresolvedOptions);
+    abstract onOptions(): OptionsType<TUnresolvedOptions, TOptions>;
+    protected returnsOptions(options: OptionsType<TUnresolvedOptions, TOptions>): OptionsType<TUnresolvedOptions, TOptions>;
+    abstract onExec(): Promise<number>;
+}

package/lib/Command/CommandAbstract.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandAbstract = void 0;
+const cli_util_1 = require("../util/cli-util");
+class CommandAbstract {
+    constructor(globalOptions, options) {
+        this.globalOptions = globalOptions;
+        this.options = (0, cli_util_1.parseOptions)(options, this.onOptions());
+    }
+    returnsOptions(options) {
+        return options;
+    }
+}
+exports.CommandAbstract = CommandAbstract;

package/lib/Command/ConfigCommand.d.ts

@@ -0,0 +1,17 @@
+import { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { If } from "../util/ts-util";
+import { CommandAbstract } from "./CommandAbstract";
+export declare type ConfigCommandOptionsType<TResolved = false> = {
+    package?: If<TResolved, string[]>;
+    repository?: If<TResolved, string[]>;
+    repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
+};
+export declare type ConfigCommandLogType = {
+    package: string;
+    repositoryNames: string[];
+    taskName: string | undefined;
+}[];
+export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptionsType<false>, ConfigCommandOptionsType<true>> {
+    onOptions(): import("../util/cli-util").OptionsType<ConfigCommandOptionsType<false>, ConfigCommandOptionsType<true>>;
+    onExec(): Promise<number>;
+}