@grest-ts/config 0.0.5

package/src/GGConfigLocator.ts

@@ -0,0 +1,112 @@
+import {GGConfigStore} from "./GGConfigStore";
+import {GGConfigKey, GGConfigKeyConstructor} from "./GGConfigKey";
+import {GGLocator, GGLocatorServiceType} from "@grest-ts/locator";
+import {GG_CONFIG} from "./GG_CONFIG";
+import {ConfigValues, GGConfigStoreLocal} from "./stores/GGConfigStoreLocal";
+
+export type GGConfigDefinition<T> = T & {
+    __isGGConfigDefinition: never,
+    __getKeysMap: () => ReadonlyMap<GGConfigKeyConstructor, GGConfigKey[]>
+};
+
+export class GGConfigLocator<T extends object> {
+
+    #isStarted = false;
+    readonly #config: GGConfigDefinition<T>;
+    readonly #storesList: GGConfigStore<GGConfigKey>[] = []
+    readonly #storesMap: Map<string, GGConfigStore<GGConfigKey>> = new Map()
+
+    protected readonly localConfig: GGConfigStoreLocal<T, any> = undefined
+
+    /**
+     * @param config - Config definition.
+     * @param localConfig - Optional local config values. If provided, stores will use this instead of the real values when not running in production.
+     *  new GGConfigLocator(MyConfig, localConfig) is shorthand for this: new GGConfigLocator(MyConfig).add(AllKeys, new GGConfigStoreLocal(MyConfig, localConfig))
+     */
+    constructor(config: GGConfigDefinition<T>, localConfig?: ConfigValues<T>) {
+        if (!config) throw new Error("Config definition is required");
+        this.#config = config;
+        this.localConfig = localConfig ? new GGConfigStoreLocal(config, localConfig) : undefined
+        GGLocator.getScope().setWithLifecycle(GG_CONFIG, this, {
+            type: GGLocatorServiceType.CONFIG,
+            start: () => this.start(),
+            teardown: () => this.teardown()
+        });
+    }
+
+    /**
+     * Can override this if you want custom handling.
+     */
+    public onNotifyError = (error: Error): never => {
+        throw error;
+    }
+
+    /**
+     * Add a config store for a key type.
+     *
+     * Note for framework development: Testkit overrides this function.
+     */
+    public add<Key extends GGConfigKey>(key: GGConfigKeyConstructor<Key> | GGConfigKeyConstructor<Key>[], store: GGConfigStore<Key>): this {
+        return this._add(key, this._useLocalStoreIfNeeded(store))
+    }
+
+    protected _useLocalStoreIfNeeded<Key extends GGConfigKey>(store: GGConfigStore<Key>): GGConfigStore<Key> {
+        if (process.env.NODE_ENV === "production" || !this.localConfig) {
+            return store;
+        } else {
+            return this.localConfig;
+        }
+    }
+
+    protected _add<Key extends GGConfigKey>(key: GGConfigKeyConstructor<Key> | GGConfigKeyConstructor<Key>[], store: GGConfigStore<Key>): this {
+        if (this.#isStarted) {
+            throw new Error("Cannot add store after config holder is started");
+        }
+        const keyTypes = Array.isArray(key) ? key : [key];
+        const keysMap = this.#config.__getKeysMap();
+        for (const keyType of keyTypes) {
+            const keysForType = (keysMap.get(keyType) ?? []) as Key[];
+            store.setKeys(keysForType);
+            this.#storesMap.set(keyType.NAME, store as GGConfigStore<GGConfigKey>);
+        }
+        if (!this.#storesList.includes(store as GGConfigStore<GGConfigKey>)) {
+            this.#storesList.push(store as GGConfigStore<GGConfigKey>);
+        }
+        return this;
+    }
+
+    public getStore<Key extends GGConfigKey>(keyType: GGConfigKeyConstructor<Key>): GGConfigStore<Key> {
+        return this.getStoreByConfigKeyName(keyType.NAME);
+    }
+
+    public getStoreByConfigKeyName<Key extends GGConfigKey>(name: string): GGConfigStore<Key> {
+        const store = this.#storesMap.get(name);
+        if (!store) {
+            throw new Error(`No store for store key: ${name ?? 'undefined'}.`);
+        }
+        return store as GGConfigStore<Key>
+    }
+
+    public getStores(): GGConfigStore<GGConfigKey>[] {
+        return this.#storesList;
+    }
+
+    public async start(): Promise<void> {
+        if (this.#isStarted) {
+            throw new Error("Already started");
+        }
+        this.#isStarted = true;
+        this.#config.__getKeysMap().forEach((_, keyType) => {
+            if (!this.#storesMap.has(keyType.NAME)) {
+                throw new Error(`Missing stores for config key type '${keyType.NAME}'`);
+            }
+        })
+        Object.freeze(this.#storesMap);
+        Object.freeze(this.#storesList);
+        await Promise.all(this.#storesList.map((store) => store.start()));
+    }
+
+    public async teardown(): Promise<void> {
+        await Promise.all(this.#storesList.map(s => s.teardown()));
+    }
+}

package/src/GGConfigStore.ts

@@ -0,0 +1,100 @@
+import {GGConfigKey} from "./GGConfigKey";
+import {GG_CONFIG} from "./GG_CONFIG";
+
+export type ConfigUpdateCallback = (value: any) => void | Promise<void>;
+
+/**
+ * Important when extending: Use resolveValue() to resolve and validate config values.
+ */
+export abstract class GGConfigStore<Key extends GGConfigKey> {
+
+    #keys: Key[] = []
+    public get keys(): readonly Key[] { return this.#keys }
+    readonly #watchers: Map<GGConfigKey, ConfigUpdateCallback[]> = new Map()
+
+    protected isStarted = false;
+
+    public get started(): boolean {
+        return this.isStarted;
+    }
+
+    public setKeys(keys: readonly Key[]): void {
+        if (this.isStarted) {
+            throw new Error(`Cannot set keys after store is started: ${this.constructor.name}`);
+        }
+        this.#keys.push(...keys);
+    }
+
+    public abstract getValue<T>(key: GGConfigKey<T>): T
+
+    /**
+     * Resolves the final value for a config key: uses storeValue if present, falls back to key.getDefault(),
+     * then validates against schema. If the resolved value is undefined and the schema doesn't allow it,
+     * validation will fail — this is how missing required keys are caught.
+     */
+    protected resolveValue<T>(key: GGConfigKey<T>, storeValue: unknown, isInitialLoad: boolean = false): T {
+        const val = storeValue !== undefined ? storeValue : key.getDefault();
+        const check = key.schema.safeParse(val);
+        if (check.success === false) {
+            const errors = JSON.stringify(check.issues.toJSON(), null, 2).replaceAll("\n", "\n\t\t")
+            throw new Error(`Config validation failed for "${key.name}" during ${isInitialLoad ? "initial-load" : "reload"}.\n\tDefined at:\n\t\t${key.definedAt}\n\tIssues:\n\t\t${errors}`);
+        } else {
+            return check.value as T;
+        }
+    }
+
+    public async start(): Promise<void> {
+        if (this.isStarted === true) {
+            throw new Error(`Config store already started: ${this.constructor.name}`);
+        }
+        this.isStarted = true;
+        Object.freeze(this.#keys);
+
+        this.keys.forEach(key => {
+            this.getValue(key); // Get every value so that config values are definitely initialized (or they would throw)
+        });
+    }
+
+    public async teardown(): Promise<void> {
+        this.#watchers.clear();
+        this.isStarted = false;
+    }
+
+    public watch(key: GGConfigKey, callback: ConfigUpdateCallback): () => void {
+        if (!this.#watchers.has(key)) {
+            this.#watchers.set(key, []);
+        }
+        this.#watchers.get(key)!.push(callback);
+        return () => {
+            const list = this.#watchers.get(key);
+            if (!list) return;
+            const index = list.indexOf(callback);
+            if (index >= 0) list.splice(index, 1);
+        };
+    }
+
+    public async notify(key: GGConfigKey) {
+        if (this.#watchers.has(key)) {
+            const promises: Promise<void>[] = [];
+            const newValue = this.getValue(key);
+            this.#watchers.get(key).forEach(callback => {
+                try {
+                    const result = callback(newValue);
+                    if (result instanceof Promise) {
+                        promises.push(result);
+                    }
+                } catch (err) {
+                    GG_CONFIG.get().onNotifyError(err);
+                }
+            })
+            if (promises.length > 0) {
+                const results = await Promise.allSettled(promises);
+                for (const result of results) {
+                    if (result.status === 'rejected') {
+                        GG_CONFIG.get().onNotifyError(result.reason);
+                    }
+                }
+            }
+        }
+    }
+}

package/src/GG_CONFIG.ts

@@ -0,0 +1,4 @@
+import {GGLocatorKey} from "@grest-ts/locator";
+import type {GGConfigLocator} from "./GGConfigLocator";
+
+export const GG_CONFIG = new GGLocatorKey<GGConfigLocator<any>>("GGConfig");

package/src/assureValidConfigPath.spec.ts

@@ -0,0 +1,140 @@
+import {describe, it, expect} from 'vitest';
+import {assureValidConfigPath} from './assureValidConfigPath';
+
+describe('assureValidConfigPath', () => {
+
+    describe('valid paths', () => {
+        it('accepts simple path', () => {
+            expect(() => assureValidConfigPath('/app/setting')).not.toThrow();
+        });
+
+        it('accepts path with multiple segments', () => {
+            expect(() => assureValidConfigPath('/app/db/host')).not.toThrow();
+        });
+
+        it('accepts path with underscores', () => {
+            expect(() => assureValidConfigPath('/my_app/my_setting')).not.toThrow();
+        });
+
+        it('accepts path with numbers after letter', () => {
+            expect(() => assureValidConfigPath('/app1/setting2')).not.toThrow();
+        });
+
+        it('accepts mixed valid characters', () => {
+            expect(() => assureValidConfigPath('/my_app_v2/db_connection_pool_size')).not.toThrow();
+        });
+
+        it('accepts uppercase letters', () => {
+            expect(() => assureValidConfigPath('/MyApp/DbHost')).not.toThrow();
+        });
+
+        it('accepts single segment', () => {
+            expect(() => assureValidConfigPath('/setting')).not.toThrow();
+        });
+    });
+
+    describe('must start with slash', () => {
+        it('rejects path without leading slash', () => {
+            expect(() => assureValidConfigPath('app/setting')).toThrow("must start with '/'");
+        });
+
+        it('rejects single word without slash', () => {
+            expect(() => assureValidConfigPath('setting')).toThrow("must start with '/'");
+        });
+    });
+
+    describe('cannot end with slash', () => {
+        it('rejects path with trailing slash', () => {
+            expect(() => assureValidConfigPath('/app/setting/')).toThrow("cannot end with '/'");
+        });
+
+        it('rejects root path (just slash)', () => {
+            expect(() => assureValidConfigPath('/')).toThrow("cannot end with '/'");
+        });
+    });
+
+    describe('no double slashes', () => {
+        it('rejects double slash in middle', () => {
+            expect(() => assureValidConfigPath('/app//setting')).toThrow("cannot contain '//'");
+        });
+
+        it('rejects double slash at start', () => {
+            expect(() => assureValidConfigPath('//app/setting')).toThrow("cannot contain '//'");
+        });
+
+        it('rejects multiple double slashes', () => {
+            expect(() => assureValidConfigPath('/app//db//host')).toThrow("cannot contain '//'");
+        });
+    });
+
+    describe('invalid characters', () => {
+        it('rejects dots', () => {
+            expect(() => assureValidConfigPath('/app/db.host')).toThrow('invalid characters');
+        });
+
+        it('rejects hyphens', () => {
+            expect(() => assureValidConfigPath('/my-app/setting')).toThrow('invalid characters');
+        });
+
+        it('rejects spaces', () => {
+            expect(() => assureValidConfigPath('/app/my setting')).toThrow('invalid characters');
+        });
+
+        it('rejects special characters @', () => {
+            expect(() => assureValidConfigPath('/app@host/setting')).toThrow('invalid characters');
+        });
+
+        it('rejects special characters #', () => {
+            expect(() => assureValidConfigPath('/app#1/setting')).toThrow('invalid characters');
+        });
+
+        it('rejects special characters $', () => {
+            expect(() => assureValidConfigPath('/app/$setting')).toThrow('invalid characters');
+        });
+
+        it('rejects special characters %', () => {
+            expect(() => assureValidConfigPath('/app/100%')).toThrow('invalid characters');
+        });
+
+        it('rejects colon', () => {
+            expect(() => assureValidConfigPath('/app:setting')).toThrow('invalid characters');
+        });
+
+        it('rejects backslash', () => {
+            expect(() => assureValidConfigPath('/app\\setting')).toThrow('invalid characters');
+        });
+    });
+
+    describe('segments must start with letter', () => {
+        it('rejects segment starting with number', () => {
+            expect(() => assureValidConfigPath('/app/1setting')).toThrow('must start with a letter');
+        });
+
+        it('rejects segment starting with underscore', () => {
+            expect(() => assureValidConfigPath('/app/_setting')).toThrow('must start with a letter');
+        });
+
+        it('rejects first segment starting with number', () => {
+            expect(() => assureValidConfigPath('/1app/setting')).toThrow('must start with a letter');
+        });
+
+        it('accepts segment with numbers after first letter', () => {
+            expect(() => assureValidConfigPath('/app/s1e2t3')).not.toThrow();
+        });
+    });
+
+    describe('max length', () => {
+        it('accepts path at exactly 2048 characters', () => {
+            const path = '/' + 'a'.repeat(2047);
+            expect(path.length).toBe(2048);
+            expect(() => assureValidConfigPath(path)).not.toThrow();
+        });
+
+        it('rejects path exceeding 2048 characters', () => {
+            const path = '/' + 'a'.repeat(2048);
+            expect(path.length).toBe(2049);
+            expect(() => assureValidConfigPath(path)).toThrow('exceeds 2048 characters');
+        });
+    });
+
+});

package/src/assureValidConfigPath.ts

@@ -0,0 +1,34 @@
+/**
+ * Validates config key name for compatibility with external providers.
+ * Rules:
+ * - Must start with forward slash
+ * - Only letters, numbers, underscore, forward slash allowed
+ * - Each segment (word) must start with a letter
+ * - No double slashes
+ * - Cannot end with slash
+ * - Max 2048 characters (AWS limit)
+ */
+export function assureValidConfigPath(path: string) {
+    if (path.length > 2048) {
+        throw new Error(`Config key name exceeds 2048 characters: ${path}`);
+    }
+    if (!path.startsWith('/')) {
+        throw new Error(`Config key name must start with '/': ${path}`);
+    }
+    if (path.endsWith('/')) {
+        throw new Error(`Config key name cannot end with '/': ${path}`);
+    }
+    if (path.includes('//')) {
+        throw new Error(`Config key name cannot contain '//': ${path}`);
+    }
+    if (!/^[a-zA-Z0-9_\/]+$/.test(path)) {
+        throw new Error(`Config key name contains invalid characters (allowed: a-z, A-Z, 0-9, _, /): ${path}`);
+    }
+    // Each segment must start with a letter
+    const segments = path.split('/').filter(s => s.length > 0);
+    for (const segment of segments) {
+        if (!/^[a-zA-Z]/.test(segment)) {
+            throw new Error(`Each path segment must start with a letter: ${path}`);
+        }
+    }
+}

package/src/index-node.ts

@@ -0,0 +1,11 @@
+export * from './GGConfig';
+export * from './GG_CONFIG';
+export * from './GGConfigLocator';
+export * from "./GGConfigKey";
+export * from "./GGConfigStore";
+export * from "./stores/GGConfigStoreFile";
+export * from "./stores/GGConfigStoreLocal";
+export * from "./keys/GGSetting";
+export * from "./keys/GGSecret";
+export * from "./keys/GGResource";
+export {assureValidConfigPath} from "./assureValidConfigPath";

package/src/keys/GGResource.ts

@@ -0,0 +1,20 @@
+import {GGConfigKey} from "../GGConfigKey";
+import {GGValidator} from "@grest-ts/schema";
+
+export class GGResource<T> extends GGConfigKey<T> {
+
+    public static readonly NAME = "[GGResource]";
+
+    constructor(name: string, schema: GGValidator<T>, description: string) {
+        super(name, schema, description);
+    }
+
+    public getStoreKey(): string {
+        return GGResource.NAME;
+    }
+
+    public get(): T {
+        return this.getValue();
+    }
+
+}

package/src/keys/GGSecret.ts

@@ -0,0 +1,20 @@
+import {GGConfigKey} from "../GGConfigKey";
+import {GGValidator} from "@grest-ts/schema";
+
+export class GGSecret<T> extends GGConfigKey<T> {
+
+    public static readonly NAME = "[GGSecret]";
+
+    constructor(name: string, schema: GGValidator<T>, description: string) {
+        super(name, schema, description);
+    }
+
+    public getStoreKey(): string {
+        return GGSecret.NAME
+    }
+
+    public reveal(): T {
+        return this.getValue();
+    }
+
+}

package/src/keys/GGSetting.ts

@@ -0,0 +1,28 @@
+import {GGConfigKey, Widen} from "../GGConfigKey";
+import {deepFreeze} from "@grest-ts/common";
+import {GGValidator} from "@grest-ts/schema";
+
+export class GGSetting<T> extends GGConfigKey<T> {
+
+    public static readonly NAME = "[GGSetting]";
+
+    readonly #default: T;
+
+    constructor(name: string, schema: GGValidator<T>, defaultValue: Widen<T>, description: string) {
+        super(name, schema, description);
+        this.#default = deepFreeze(defaultValue as T);
+    }
+
+    public override getDefault(): T {
+        return this.#default;
+    }
+
+    public getStoreKey(): string {
+        return GGSetting.NAME
+    }
+
+    public get(): T {
+        return this.getValue();
+    }
+
+}

package/src/stores/GGConfigStoreFile.ts

@@ -0,0 +1,69 @@
+import * as fs from 'fs';
+import {GGConfigStore} from "../GGConfigStore";
+import {GGConfigKey} from "../GGConfigKey";
+import {dirname, join} from "node:path";
+import {fileURLToPath} from "node:url";
+
+/**
+ * Local file-based settings strategy.
+ * Reads settings from settings.json in the config directory.
+ * Watches file for changes and automatically reloads.
+ */
+export class GGConfigStoreFile<Key extends GGConfigKey> extends GGConfigStore<Key> {
+
+    private readonly file: string;
+    #watcher: fs.FSWatcher | null = null;
+    #debounceTimer: NodeJS.Timeout | null = null;
+    #valuesCache: Map<GGConfigKey, unknown> = new Map();
+
+    constructor(file: string, moduleUrl?: string) {
+        super();
+        const prefix = moduleUrl ? dirname(fileURLToPath(moduleUrl)) : "";
+        this.file = join(prefix, file);
+    }
+
+    public override async start(): Promise<void> {
+        await super.start();
+        await this.refresh(true);
+        this.#watcher = fs.watch(this.file, (eventType) => {
+            if (eventType === 'change') {
+                if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
+                // Adding debounce so file writes would have time to correctly complete.
+                this.#debounceTimer = setTimeout(() => this.refresh(false), 100);
+            }
+        });
+    }
+
+    public override async teardown(): Promise<void> {
+        if (this.#watcher) {
+            this.#watcher.close();
+            this.#watcher = null;
+        }
+        await super.teardown();
+    }
+
+    public async refresh(isInitialLoad: boolean): Promise<void> {
+        const fileContent = fs.readFileSync(this.file, 'utf-8');
+        if (!fileContent) {
+            throw new Error("Settings file is empty! Why is that?")
+        }
+        const fileJson = JSON.parse(fileContent);
+        this.#valuesCache.clear();
+        this.keys.forEach(key => {
+            const path = key.name.split("/");
+            let val: any = undefined;
+            if (path.length > 1) {
+                val = fileJson;
+                for (let i = 1; i < path.length; i++) {
+                    val = val?.[path[i]]
+                }
+            }
+            this.#valuesCache.set(key, this.resolveValue(key, val, isInitialLoad));
+        });
+    }
+
+    public getValue<T>(key: GGConfigKey<T>): T {
+        return this.#valuesCache.get(key) as T;
+    }
+
+}

package/src/stores/GGConfigStoreLocal.ts

@@ -0,0 +1,110 @@
+import {GGConfigStore} from "../GGConfigStore";
+import {GGConfigKey, Widen} from "../GGConfigKey";
+import {deepFreeze} from "@grest-ts/common";
+
+/**
+ * Extracts the keys from T that are GGConfigKey instances or objects containing them.
+ * Uses a depth limit (D) to prevent infinite recursion on circular types (e.g. GGSchema).
+ */
+type ConfigKeyOf<T, D extends 1[] = []> = D['length'] extends 5 ? never : {
+    [K in keyof T]: [T[K]] extends [never] ? never :
+        T[K] extends GGConfigKey<any> ? K :
+            T[K] extends Function ? never :
+                T[K] extends object ? (ConfigKeyOf<T[K], [...D, 1]> extends never ? never : K) : never
+}[keyof T];
+
+/**
+ * Maps a config definition to the shape of values it expects.
+ * GGConfigKey<V> → V, objects with config keys → recurse, everything else → excluded.
+ */
+export type ConfigValues<T, D extends 1[] = []> =
+    D['length'] extends 5 ? never :
+        T extends GGConfigKey<infer V> ? Widen<V> :
+            T extends object ? (
+                ConfigKeyOf<T, D> extends never ? never : { [K in ConfigKeyOf<T, D>]: ConfigValues<T[K], [...D, 1]> }
+                ) : never;
+
+/**
+ * Type-checks a local config values object against a config definition.
+ * Returns the values object as-is — this is a compile-time helper, not a store.
+ *
+ * Use with GGConfigStoreLocal in your runtime's compose():
+ * @example
+ * ```typescript
+ * // config/local.ts — just data:
+ * export default createLocalConfig(MyConfig, {
+ *     mysql: {
+ *         host: { host: "localhost", port: 3306, database: "mydb" },
+ *         user: { username: "root", password: "root" },
+ *     },
+ *     jwtSecret: "dev-secret",
+ * })
+ *
+ * // runtime.ts — fresh store per compose():
+ * import localConfig from "./config/local.js";
+ * new GGConfigLocator(MyConfig)
+ *     .add([GGResource, GGSecret], new GGConfigStoreLocal(MyConfig, localConfig))
+ * ```
+ */
+export function createLocalConfig<T extends object>(_config: T, values: ConfigValues<T>): ConfigValues<T> {
+    deepFreeze(values)
+    return values;
+}
+
+/**
+ * Type-safe local development config store.
+ * Refuses to start in production — crashes immediately if NODE_ENV is "production".
+ * Use createLocalConfig() for the best DX, or .set() for manual control.
+ */
+export class GGConfigStoreLocal<Struct extends object, Key extends GGConfigKey = GGConfigKey> extends GGConfigStore<Key> {
+
+    readonly #values = new Map<GGConfigKey, unknown>();
+    readonly #valuesCache = new Map<GGConfigKey, unknown>();
+
+    constructor(config: Struct, values: ConfigValues<Struct>) {
+        super();
+        walkAndSet(this, config, values);
+    }
+
+    public set<T>(key: GGConfigKey<T>, value: T): this {
+        this.#values.set(key, value);
+        return this;
+    }
+
+    public override async start(): Promise<void> {
+        if (process.env.NODE_ENV === "production") {
+            throw new Error(
+                "GGConfigStoreLocal cannot be used in production. " +
+                "Use GGConfigStoreAwsSecretsManager or another production-safe store."
+            );
+        }
+
+        this.keys.forEach(key => {
+            this.#valuesCache.set(key, this.resolveValue(key, this.#values.get(key), true));
+        });
+
+        await super.start();
+    }
+
+    public override async teardown(): Promise<void> {
+        this.#valuesCache.clear();
+        await super.teardown();
+    }
+
+    public getValue<T>(key: GGConfigKey<T>): T {
+        return this.#valuesCache.get(key) as T;
+    }
+
+}
+
+function walkAndSet(store: GGConfigStoreLocal<any>, config: any, values: any) {
+    for (const prop of Object.keys(values)) {
+        const configEntry = config[prop];
+        const value = values[prop];
+        if (configEntry instanceof GGConfigKey) {
+            store.set(configEntry, value);
+        } else if (configEntry != null && typeof configEntry === 'object' && value != null && typeof value === 'object') {
+            walkAndSet(store, configEntry, value);
+        }
+    }
+}

package/src/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "//": "THIS FILE IS GENERATED - DO NOT EDIT",
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "lib": [
+      "ES2022"
+    ],
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "**/*"
+  ]
+}