@adviser/cement 0.5.0 → 0.5.1

package/src/app-context.ts

@@ -1,20 +1,71 @@
-/*
- * Context class to store and retrieve values
- * it's used to store user runtime values like
- * the url to the ledger
+/**
+ * Type guard to check if a value is an AppContext instance.
+ *
+ * @param ctx - Value to check
+ * @returns True if value is an AppContext instance
+ *
+ * @example
+ * ```typescript
+ * const ctx = new AppContext();
+ * if (isAppContext(ctx)) {
+ *   ctx.set('key', 'value');
+ * }
+ * ```
  */
-
 export function isAppContext(ctx: unknown): ctx is AppContext {
   return AppContext.is(ctx);
 }
 
+/**
+ * Context container for storing and retrieving runtime values.
+ *
+ * AppContext provides a type-safe key-value store for application configuration
+ * and runtime state. Useful for passing configuration like URLs, credentials,
+ * or other runtime parameters through an application.
+ *
+ * @example
+ * ```typescript
+ * const ctx = new AppContext();
+ * ctx.set('apiUrl', 'https://api.example.com');
+ * ctx.set('timeout', 5000);
+ *
+ * const url = ctx.get<string>('apiUrl');
+ * const timeout = ctx.get<number>('timeout');
+ * ```
+ */
 export class AppContext {
   private readonly ctx: Map<string, unknown> = new Map<string, unknown>();
 
+  /**
+   * Type guard to check if a value is an AppContext instance.
+   *
+   * @param ctx - Value to check
+   * @returns True if value is an AppContext instance
+   */
   static is(ctx: unknown): ctx is AppContext {
     return ctx instanceof AppContext && "ctx" in ctx && ctx.ctx instanceof Map;
   }
 
+  /**
+   * Merges multiple contexts or objects into a single AppContext.
+   *
+   * Combines values from multiple AppContext instances or plain objects.
+   * Later values overwrite earlier ones for duplicate keys. Undefined values
+   * are skipped.
+   *
+   * @param ctxs - AppContext instances, plain objects, or undefined values to merge
+   * @returns New AppContext containing merged values
+   *
+   * @example
+   * ```typescript
+   * const ctx1 = new AppContext().set('a', 1).set('b', 2);
+   * const ctx2 = new AppContext().set('b', 3).set('c', 4);
+   * const obj = { d: 5 };
+   *
+   * const merged = AppContext.merge(ctx1, ctx2, obj);
+   * // Contains: { a: 1, b: 3, c: 4, d: 5 }
+   * ```
+   */
   static merge(...ctxs: (AppContext | undefined | Record<string, unknown>)[]): AppContext {
     const merged = new AppContext();
     for (const ctx of ctxs) {
@@ -32,17 +83,72 @@ export class AppContext {
     return merged;
   }
 
+  /**
+   * Sets a value in the context.
+   *
+   * @template T - Type of the value being stored
+   * @param key - Key to store the value under
+   * @param value - Value to store
+   * @returns This AppContext instance for chaining
+   *
+   * @example
+   * ```typescript
+   * ctx.set('apiUrl', 'https://api.example.com')
+   *    .set('timeout', 5000)
+   *    .set('retries', 3);
+   * ```
+   */
   set<T>(key: string, value: T): AppContext {
     this.ctx.set(key, value);
     return this;
   }
+
+  /**
+   * Retrieves a value from the context.
+   *
+   * @template T - Expected type of the value
+   * @param key - Key to retrieve
+   * @returns The value if present, undefined otherwise
+   *
+   * @example
+   * ```typescript
+   * const url = ctx.get<string>('apiUrl');
+   * const timeout = ctx.get<number>('timeout');
+   * ```
+   */
   get<T>(key: string): T | undefined {
     return this.ctx.get(key) as T;
   }
+
+  /**
+   * Deletes a value from the context.
+   *
+   * @param key - Key to delete
+   *
+   * @example
+   * ```typescript
+   * ctx.delete('temporaryKey');
+   * ```
+   */
   delete(key: string): void {
     this.ctx.delete(key);
   }
 
+  /**
+   * Converts the context to a plain object.
+   *
+   * @returns Plain object containing all key-value pairs
+   *
+   * @example
+   * ```typescript
+   * const ctx = new AppContext()
+   *   .set('a', 1)
+   *   .set('b', 2);
+   *
+   * const obj = ctx.asObj();
+   * // { a: 1, b: 2 }
+   * ```
+   */
   asObj(): Record<string, unknown> {
     return Object.fromEntries(this.ctx.entries());
   }

package/src/base-sys-abstraction.ts

@@ -7,16 +7,23 @@ import {
   SystemService,
   VoidFunc,
   BasicSysAbstraction,
-  BasicRuntimeService,
+  type BasicRuntimeService,
 } from "./sys-abstraction.js";
 import { Time } from "./time.js";
 import { TxtEnDecoder } from "./txt-en-decoder.js";
-import { WebBasicSysAbstraction } from "./web/web-basic-sys-abstraction.js";
+import { WebBasicSysAbstraction } from "./web-env/index.js";
 import { Env } from "./sys-env.js";
-import { CFBasicSysAbstraction } from "./cf/cf-basic-sys-abstraction.js";
-import { DenoBasicSysAbstraction } from "./deno/deno-basic-sys-abstraction.js";
-import { NodeBasicSysAbstraction } from "./node/node-basic-sys-abstraction.js";
+import { CFBasicSysAbstraction } from "./cf-env/index.js";
+import { DenoBasicSysAbstraction } from "./deno-env/index.js";
+import { NodeBasicSysAbstraction } from "./node-env/index.js";
+import { WithCement } from "@adviser/cement";
+import { addCement } from "./add-cement-do-not-export.js";
 
+/**
+ * Real-time implementation using system clock.
+ *
+ * Provides actual current time and real delays. Use for production code.
+ */
 export class SysTime extends Time {
   Now(): Date {
     return new Date();
@@ -30,6 +37,12 @@ export class SysTime extends Time {
   }
 }
 
+/**
+ * Constant time implementation for deterministic testing.
+ *
+ * Always returns the same fixed date (2021-02-01). Sleep operations
+ * complete immediately without delay. Useful for reproducible tests.
+ */
 export class ConstTime extends Time {
   Now(): Date {
     return new Date(2021, 1, 1, 0, 0, 0, 0);
@@ -40,6 +53,12 @@ export class ConstTime extends Time {
   }
 }
 
+/**
+ * Stepped time implementation for controlled testing.
+ *
+ * Advances time in 1-second increments on each Now() call. Sleep operations
+ * advance time without delay. Useful for testing time-dependent behavior.
+ */
 export class StepTime extends Time {
   _step: Date;
   readonly _start: Date;
@@ -68,6 +87,24 @@ export class StepTime extends Time {
   }
 }
 
+/**
+ * Creates a Time implementation based on the specified mode.
+ *
+ * @param timeMode - Time behavior mode (REAL, CONST, or STEP)
+ * @returns Time implementation matching the mode
+ *
+ * @example
+ * ```typescript
+ * // Production: uses real system time
+ * const realTime = TimeFactory(TimeMode.REAL);
+ *
+ * // Testing: constant time
+ * const constTime = TimeFactory(TimeMode.CONST);
+ *
+ * // Testing: stepped time
+ * const stepTime = TimeFactory(TimeMode.STEP);
+ * ```
+ */
 export function TimeFactory(timeMode: TimeMode): Time {
   switch (timeMode) {
     case TimeMode.REAL:
@@ -80,12 +117,42 @@ export function TimeFactory(timeMode: TimeMode): Time {
   return new SysTime();
 }
 
+/**
+ * Random number generator with deterministic modes for testing.
+ *
+ * Provides random number generation that can operate in different modes:
+ * - RANDOM: Uses Math.random() for real random values
+ * - CONST: Always returns a constant value (0.5 * max) for reproducible tests
+ * - STEP: Returns incrementing values for predictable test sequences
+ *
+ * @example
+ * ```typescript
+ * // Production: real randomness
+ * const random = new RandomService(RandomMode.RANDOM);
+ * const value = random.Random0ToValue(100); // 0-100
+ *
+ * // Testing: constant value
+ * const constRandom = new RandomService(RandomMode.CONST);
+ * const value = constRandom.Random0ToValue(100); // Always 50
+ *
+ * // Testing: stepped sequence
+ * const stepRandom = new RandomService(RandomMode.STEP);
+ * const v1 = stepRandom.Random0ToValue(100); // 0.01
+ * const v2 = stepRandom.Random0ToValue(100); // 0.02
+ * ```
+ */
 export class RandomService {
   readonly _mode: RandomMode;
   _step = 0;
   constructor(mode: RandomMode) {
     this._mode = mode;
   }
+  /**
+   * Generates a random number between 0 and the specified value.
+   *
+   * @param value - Maximum value (exclusive upper bound)
+   * @returns Random number in range [0, value)
+   */
   Random0ToValue(value: number): number {
     switch (this._mode) {
       case RandomMode.CONST:
@@ -101,6 +168,31 @@ export class RandomService {
   }
 }
 
+/**
+ * ID generator with deterministic modes for testing.
+ *
+ * Generates unique identifiers with support for different modes:
+ * - UUID: Uses crypto.randomUUID() for real UUIDs (default)
+ * - CONST: Always returns the same constant ID for reproducible tests
+ * - STEP: Returns incrementing IDs (STEPId-0, STEPId-1, etc.) for predictable sequences
+ *
+ * @example
+ * ```typescript
+ * // Production: real UUIDs
+ * const idService = new IdService(IDMode.UUID);
+ * const id = idService.NextId(); // "550e8400-e29b-41d4-a716-446655440000"
+ *
+ * // Testing: constant ID
+ * const constId = new IdService(IDMode.CONST);
+ * const id1 = constId.NextId(); // "VeryUniqueID"
+ * const id2 = constId.NextId(); // "VeryUniqueID"
+ *
+ * // Testing: stepped sequence
+ * const stepId = new IdService(IDMode.STEP);
+ * const id1 = stepId.NextId(); // "STEPId-0"
+ * const id2 = stepId.NextId(); // "STEPId-1"
+ * ```
+ */
 export class IdService {
   readonly _mode: IDMode;
   _step = 0;
@@ -110,6 +202,11 @@ export class IdService {
     }
     this._mode = mode;
   }
+  /**
+   * Generates the next unique identifier.
+   *
+   * @returns Unique ID string based on the configured mode
+   */
   NextId(): string {
     switch (this._mode) {
       case IDMode.UUID:
@@ -145,6 +242,29 @@ export interface ExitService {
 
 // some black magic to make it work with CF workers
 
+/**
+ * Base system abstraction for platform-independent services.
+ *
+ * Provides core services that work across all JavaScript runtimes:
+ * - Time: Real system time implementation
+ * - ID Generation: UUID-based unique identifiers
+ * - Random Numbers: Math.random()-based generation
+ * - Text Encoding/Decoding: UTF-8 conversion utilities
+ *
+ * This is the foundation for both basic and full system abstractions,
+ * containing services that don't require filesystem or system access.
+ *
+ * @example
+ * ```typescript
+ * const base = new BaseBasicSysAbstraction({
+ *   TxtEnDecoder: new TxtEnDecoder()
+ * });
+ *
+ * const now = base._time.Now();
+ * const id = base._idService.NextId();
+ * const random = base._randomService.Random0ToValue(100);
+ * ```
+ */
 export class BaseBasicSysAbstraction {
   readonly _time: SysTime = new SysTime();
 
@@ -158,6 +278,31 @@ export class BaseBasicSysAbstraction {
   }
 }
 
+/**
+ * Full system abstraction with filesystem and system service access.
+ *
+ * Extends BaseBasicSysAbstraction with platform-specific services:
+ * - FileSystem: File I/O operations
+ * - SystemService: Process, environment, and system-level operations
+ *
+ * Used in Node.js and Deno environments where full system access is available.
+ * Not suitable for browser or Cloudflare Workers environments.
+ *
+ * @example
+ * ```typescript
+ * const sys = new BaseSysAbstraction({
+ *   TxtEnDecoder: new TxtEnDecoder(),
+ *   FileSystem: new NodeFileService(),
+ *   SystemService: new NodeSystemService()
+ * });
+ *
+ * // Access filesystem
+ * const content = await sys._fileSystem.readFile('/path/to/file');
+ *
+ * // Access environment
+ * const env = sys._systemService.getEnv();
+ * ```
+ */
 export class BaseSysAbstraction extends BaseBasicSysAbstraction {
   // system related services
   readonly _fileSystem: FileService;
@@ -182,22 +327,96 @@ export interface BasicSysAbstractionParams {
 
 export type WrapperBasicSysAbstractionParams = Partial<BasicRuntimeService & BasicSysAbstractionParams>;
 
+export type BaseBasicRuntimeSysAbstractionParams =
+  | (BasicRuntimeService & BasicSysAbstractionParams)
+  | (BasicRuntimeService & BaseSysAbstractionParams);
+
+export type WithCementWrapperSysAbstractionParams = WithCement<Partial<BaseBasicRuntimeSysAbstractionParams>>;
+/**
+ * Creates a BasicSysAbstraction instance for the current runtime environment.
+ *
+ * Automatically detects the JavaScript runtime (Browser, Node.js, Deno, or
+ * Cloudflare Workers) and returns the appropriate system abstraction implementation.
+ * Supports optional configuration for time, ID, and random number generation modes,
+ * useful for testing with deterministic behavior.
+ *
+ * @param params - Optional configuration for time, ID, and random modes
+ * @returns BasicSysAbstraction instance for the current runtime
+ * @throws Error if the runtime cannot be detected
+ *
+ * @example
+ * ```typescript
+ * // Production: auto-detect runtime with defaults
+ * const sys = BasicSysAbstractionFactory();
+ * const now = sys.Time().Now();
+ * const id = sys.NextId();
+ *
+ * // Testing: deterministic behavior
+ * const testSys = BasicSysAbstractionFactory({
+ *   TimeMode: TimeMode.CONST,
+ *   IdMode: IDMode.STEP,
+ *   RandomMode: RandomMode.CONST
+ * });
+ * const constTime = testSys.Time().Now(); // Always 2021-02-01
+ * const id1 = testSys.NextId(); // "STEPId-0"
+ * const id2 = testSys.NextId(); // "STEPId-1"
+ * ```
+ */
+
 export function BasicSysAbstractionFactory(params?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
   const fn = runtimeFn();
   switch (true) {
     case fn.isBrowser:
-      return WebBasicSysAbstraction(params);
+      return WebBasicSysAbstraction(addCement(params));
     case fn.isDeno:
-      return DenoBasicSysAbstraction(params);
+      return DenoBasicSysAbstraction(addCement(params));
     case fn.isCFWorker:
-      return CFBasicSysAbstraction(params);
+      return CFBasicSysAbstraction(addCement(params));
     case fn.isNodeIsh:
-      return NodeBasicSysAbstraction(params);
+      return NodeBasicSysAbstraction(addCement(params));
     default:
       throw new Error("Unknown runtime");
   }
 }
 
+/**
+ * BasicSysAbstraction implementation with configurable service modes.
+ *
+ * Wraps a base system abstraction and allows overriding time, ID, and random
+ * number generation modes. This is the primary implementation returned by
+ * BasicSysAbstractionFactory and provides the unified interface for all
+ * platform-independent system services.
+ *
+ * Delegates runtime-specific operations (Stdout, Stderr, Env, Args) to the
+ * underlying runtime service while providing configurable implementations for
+ * testable services (Time, ID, Random).
+ *
+ * @example
+ * ```typescript
+ * // Created via factory
+ * const sys = BasicSysAbstractionFactory({
+ *   TimeMode: TimeMode.STEP,
+ *   IdMode: IDMode.UUID,
+ *   RandomMode: RandomMode.RANDOM
+ * });
+ *
+ * // Use time service
+ * const time = sys.Time();
+ * const now = time.Now();
+ * await time.Sleep(1000);
+ *
+ * // Use ID service
+ * const id = sys.NextId();
+ *
+ * // Use random service
+ * const random = sys.Random0ToValue(100);
+ *
+ * // Access runtime services
+ * const stdout = sys.Stdout();
+ * const env = sys.Env();
+ * const args = sys.Args();
+ * ```
+ */
 export class WrapperBasicSysAbstraction implements BasicSysAbstraction {
   readonly _time: Time;
   readonly _idService: IdService;
@@ -253,6 +472,39 @@ export class WrapperBasicSysAbstraction implements BasicSysAbstraction {
 }
 // export const BaseSysAbstraction = new BaseSysAbstractionImpl()
 
+/**
+ * Full system abstraction with filesystem and system service access.
+ *
+ * Extends WrapperBasicSysAbstraction with filesystem and system services,
+ * providing the complete system abstraction interface. Used in environments
+ * with full system access (Node.js, Deno) where filesystem operations,
+ * process management, and environment access are available.
+ *
+ * Inherits all configurable services from WrapperBasicSysAbstraction (Time,
+ * ID, Random) and adds FileSystem and SystemService access.
+ *
+ * @example
+ * ```typescript
+ * // Created via runtime-specific factory
+ * const sys = NodeSysAbstraction({
+ *   TimeMode: TimeMode.REAL,
+ *   IdMode: IDMode.UUID
+ * });
+ *
+ * // Use basic services
+ * const time = sys.Time();
+ * const id = sys.NextId();
+ *
+ * // Use filesystem
+ * const fs = sys.FileSystem();
+ * const content = await fs.readFile('/path/to/file');
+ *
+ * // Use system services
+ * const system = sys.System();
+ * const env = system.getEnv();
+ * system.exit(0);
+ * ```
+ */
 export class WrapperRuntimeSysAbstraction extends WrapperBasicSysAbstraction {
   readonly _systemService: SystemService;
   readonly _fileSystem: FileService;

package/src/bin2text.ts

@@ -1,3 +1,22 @@
+/**
+ * Formats binary data as hexdump output with ASCII representation.
+ *
+ * Produces hexdump-style output similar to `xxd` or `hexdump` commands,
+ * showing hex values and ASCII characters side-by-side. Each line shows
+ * 16 bytes with offset, hex values, and printable ASCII characters.
+ *
+ * @param hex - Binary data to format (any ArrayBufferView)
+ * @param lineFn - Callback function invoked for each formatted line
+ * @param size - Maximum number of bytes to format (0 = all bytes)
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
+ * bin2text(data, (line) => console.log(line));
+ * // Output:
+ * // 0000   48 65 6c 6c 6f 20 57 6f 72 6c 64       Hello World
+ * ```
+ */
 export function bin2text(hex: ArrayBufferView, lineFn: (line: string) => void, size = 0): void {
   const arr = new Uint8Array(hex.buffer, hex.byteOffset, hex.byteLength);
   let cutted = "  ";
@@ -34,6 +53,24 @@ export function bin2text(hex: ArrayBufferView, lineFn: (line: string) => void, s
   }
 }
 
+/**
+ * Formats binary data as a hexdump string.
+ *
+ * Convenience wrapper around bin2text that returns a single string with
+ * newline-separated hexdump lines. Useful for logging or display purposes.
+ *
+ * @param hex - Binary data to format (any ArrayBufferView)
+ * @param size - Maximum number of bytes to format (0 = all bytes)
+ * @returns Formatted hexdump as a string
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([72, 101, 108, 108, 111]);
+ * const dump = bin2string(data);
+ * console.log(dump);
+ * // 0000   48 65 6c 6c 6f                       Hello
+ * ```
+ */
 export function bin2string(hex: ArrayBufferView, size = 0): string {
   const collector: string[] = [];
   bin2text(

package/src/cf-env/cf-basic-sys-abstraction.ts

@@ -0,0 +1,85 @@
+import {
+  BaseBasicRuntimeSysAbstractionParams,
+  BaseBasicSysAbstraction,
+  WrapperBasicSysAbstraction,
+} from "../base-sys-abstraction.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory, EnvFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class CFRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  readonly _envFactory: EnvFactory;
+  constructor(ende: TxtEnDecoder, envFactory: EnvFactory) {
+    this._txtEnDe = ende;
+    this._envFactory = envFactory;
+  }
+  Env(): Env {
+    return this._envFactory();
+  }
+  Args(): string[] {
+    throw new Error("Args-Method not implemented.");
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.log(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.error(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+}
+
+function consumeReadableStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  writeFn: (chunk: Uint8Array) => Promise<void>,
+): void {
+  reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        return;
+      }
+      writeFn(value)
+        .then(() => {
+          consumeReadableStream(reader, writeFn);
+        })
+        .catch((e) => {
+          // eslint-disable-next-line no-console
+          console.error("consumeReadableStream:writeFn", e);
+        });
+    })
+    .catch((e) => {
+      // eslint-disable-next-line no-console
+      console.error("consumeReadableStream:read", e);
+    });
+}
+
+function CFWriteableStream(writeFn: (chunk: Uint8Array) => Promise<void>): WritableStream<Uint8Array> {
+  const ts = new TransformStream<Uint8Array, Uint8Array>();
+  consumeReadableStream(ts.readable.getReader(), writeFn);
+  return ts.writable;
+}
+
+let baseSysAbstraction: BaseBasicSysAbstraction | undefined = undefined;
+export function CFBasicSysAbstraction(param: Partial<BaseBasicRuntimeSysAbstractionParams>): BasicSysAbstraction {
+  const ende = param?.TxtEnDecoder || TxtEnDecoderSingleton();
+  baseSysAbstraction =
+    baseSysAbstraction ??
+    new BaseBasicSysAbstraction({
+      TxtEnDecoder: ende,
+    });
+  return new WrapperBasicSysAbstraction(baseSysAbstraction, {
+    basicRuntimeService: new CFRuntimeService(ende, envFactory),
+    ...param,
+  });
+}

package/src/cf-env/cf-env-actions.ts

@@ -0,0 +1,55 @@
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts, EnvImpl } from "../sys-env.js";
+
+let once: CFEnvActions | undefined = undefined;
+export class CFEnvActions implements EnvActions {
+  readonly injectOnRegister: Record<string, string> = {};
+  readonly cfEnv: Map<string, string>;
+  readonly opts: Partial<EnvFactoryOpts>;
+  env?: EnvImpl;
+  static new(opts: Partial<EnvFactoryOpts> = {}): EnvActions {
+    once = once ?? new CFEnvActions(opts);
+    return once;
+  }
+  static inject(o: Record<string, string>): void {
+    const env = CFEnvActions.new() as CFEnvActions;
+    for (const key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        if (env.env) {
+          env.env.set(key, value);
+        } else {
+          env.injectOnRegister[key] = value;
+        }
+      }
+    }
+  }
+  private constructor(env: Partial<EnvFactoryOpts>) {
+    this.cfEnv = new Map<string, string>(Object.entries(env.presetEnv || {}));
+    this.opts = env;
+  }
+  active(): boolean {
+    return runtimeFn().isCFWorker;
+  }
+  register(env: Env): Env {
+    this.env = env as EnvImpl;
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
+    }
+    return env;
+  }
+  get(key: string): string | undefined {
+    return this.cfEnv.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.cfEnv.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.cfEnv.keys());
+  }
+}