unikvs 0.0.13 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unikvs",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "A modular and portable KVS client implemented in TypeScript.",
   "homepage": "https://tai-kun.github.io/unikvs/",
   "license": "MIT",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@tai-kun/valibot-extra-lab": "^0.0.5",
-    "@unikvs/core": "0.0.13",
+    "@unikvs/core": "0.0.14",
     "abort-signal-utils": "^0.0.6",
     "asyncmux": "^0.0.12",
     "call-fn-once": "^0.0.12",
@@ -35,14 +35,14 @@
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^8.0.2",
     "@rolldown/plugin-babel": "^0.2.4",
-    "@unikvs/allow-repair": "0.0.13",
-    "@unikvs/checksum": "0.0.13",
-    "@unikvs/compression": "0.0.13",
-    "@unikvs/fs.node": "0.0.13",
-    "@unikvs/memory": "0.0.13",
-    "@unikvs/opfs": "0.0.13",
+    "@unikvs/allow-repair": "0.0.14",
+    "@unikvs/checksum": "0.0.14",
+    "@unikvs/compression": "0.0.14",
+    "@unikvs/fs.node": "0.0.14",
+    "@unikvs/memory": "0.0.14",
+    "@unikvs/opfs": "0.0.14",
     "@unikvs/testing": "0.0.0",
-    "@unikvs/utils": "0.0.13",
+    "@unikvs/utils": "0.0.14",
     "@vitest/browser-playwright": "5.0.5",
     "@vitest/coverage-istanbul": "5.0.5",
     "@vitest/coverage-v8": "5.0.5",

package/src/_middleware.ts

@@ -20,6 +20,11 @@ const instances = /* #__PURE__ */ new WeakMap<IMiddleware, UniKvsMiddleware>();
  * ミドルウェアを安全に使うための検証などの処理が集約されています。
  */
 export default class UniKvsMiddleware {
+  /**
+   * ミドルウェアの名前です。
+   */
+  public readonly name: string;
+
   /**
    * ラップするミドルウェアです。
    */
@@ -30,11 +35,6 @@ export default class UniKvsMiddleware {
    */
   readonly #lifecycle: PluginLifecycle<IMiddleware.OpenContext, IMiddleware.CloseContext>;
 
-  /**
-   * ミドルウェアの名前です。
-   */
-  public readonly name: string;
-
   private constructor(middleware: IMiddleware) {
     this.#mw = middleware;
     this.#lifecycle = new PluginLifecycle(middleware);

package/src/_pipeline-graph.helpers.ts

@@ -16,7 +16,7 @@ import type {
   IActiveLeafChecker,
 } from "./_pipeline-graph.types.js";
 import { ReadableStreamSchema } from "./_streams.schemas.js";
-import { parseOutput } from "./_valibot.js";
+import * as v from "./_valibot.js";
 import { MiddlewareDestinationFrozenError, MiddlewareDestinationMissingError } from "./errors.js";
 
 /**
@@ -130,7 +130,7 @@ export function requireStreamDestination(
 ): IReadableStream {
   const destination = requireDestination(middleware, ctx, operation);
 
-  return parseOutput(ReadableStreamSchema, destination);
+  return v.parseOutput(ReadableStreamSchema, destination);
 }
 
 /**

package/src/_storage.ts

@@ -4,7 +4,7 @@ import { callFnOnce } from "call-fn-once";
 
 import { PluginLifecycle } from "./_plugin-lifecycle.js";
 import { ReadableStreamSchema, WritableStreamSchema } from "./_streams.schemas.js";
-import { parseOutput } from "./_valibot.js";
+import * as v from "./_valibot.js";
 import {
   type PluginOperationAggregateError,
   StorageIsNotOpenError,
@@ -23,6 +23,11 @@ const instances = /* #__PURE__ */ new WeakMap<IStorage, UniKvsStorage>();
  * ストレージを安全に使うための検証などの処理が集約されています。
  */
 export default class UniKvsStorage {
+  /**
+   * ストレージの名前です。
+   */
+  public readonly name: string;
+
   /**
    * ラップするストレージです。
    */
@@ -33,11 +38,6 @@ export default class UniKvsStorage {
    */
   readonly #lifecycle: PluginLifecycle<IStorage.OpenContext, IStorage.CloseContext>;
 
-  /**
-   * ストレージの名前です。
-   */
-  public readonly name: string;
-
   private constructor(storage: IStorage) {
     this.#io = storage;
     this.#lifecycle = new PluginLifecycle(storage);
@@ -175,7 +175,7 @@ export default class UniKvsStorage {
 
     const output = await this.#io.getReadable(c);
 
-    return parseOutput(ReadableStreamSchema, output);
+    return v.parseOutput(ReadableStreamSchema, output);
   }
 
   /**
@@ -196,7 +196,7 @@ export default class UniKvsStorage {
 
     const output = await this.#io.getWritable(c);
 
-    return parseOutput(WritableStreamSchema, output);
+    return v.parseOutput(WritableStreamSchema, output);
   }
 
   /**

package/src/_streams.schemas.ts

@@ -2,7 +2,7 @@ import type { IReadableStream, IWritableStream } from "@unikvs/core";
 import type { CustomIssue, CustomSchema, ErrorMessage } from "valibot";
 
 import { isReadableStream, isWritableStream } from "./_streams.js";
-import { custom } from "./_valibot.js";
+import * as v from "./_valibot.js";
 
 /**
  * `ReadableStream` のインターフェースを満たすかを検証するためのスキーマです。
@@ -10,7 +10,7 @@ import { custom } from "./_valibot.js";
 export const ReadableStreamSchema: CustomSchema<
   IReadableStream,
   ErrorMessage<CustomIssue> | undefined
-> = custom<IReadableStream>(isReadableStream, "Expected a ReadableStream");
+> = v.custom<IReadableStream>(isReadableStream, "Expected a ReadableStream");
 
 /**
  * `WritableStream` のインターフェースを満たすかを検証するためのスキーマです。
@@ -18,4 +18,4 @@ export const ReadableStreamSchema: CustomSchema<
 export const WritableStreamSchema: CustomSchema<
   IWritableStream,
   ErrorMessage<CustomIssue> | undefined
-> = custom<IWritableStream>(isWritableStream, "Expected a WritableStream");
+> = v.custom<IWritableStream>(isWritableStream, "Expected a WritableStream");

package/src/_unikvs-branch.ts

@@ -1,5 +1,6 @@
 import type UniKvsMiddleware from "./_middleware.js";
 import type UniKvsStorage from "./_storage.js";
+import { InvalidForkError } from "./errors.js";
 import type { IUniKvsBranch } from "./unikvs-branch.js";
 
 /**
@@ -46,47 +47,38 @@ export const branchStates: WeakMap<IUniKvsBranch, BranchState> = /* #__PURE__ */
 >();
 
 /**
- * 分岐先のスナップショットを返します。
+ * 分岐先を親の接頭辞付きで追加します。
  *
- * 親の `fork` で接頭辞付加するために使用します。
  * `new Branch()` で作成された分岐以外の値が渡されたときは例外を投げます。
  * 外部からは使用しません。
  *
- * @param branch スナップショットを取得する分岐です。
- *
- * @returns 分岐先のコピーを返します。
- */
-export function getBranchDestinationsForFork(branch: IUniKvsBranch): BranchDestination[] {
-  const state = branchStates.get(branch);
-
-  if (!state) {
-    throw new TypeError("fork() expects a branch created by new Branch().");
-  }
-
-  // コピーを返します。親の fork で接頭辞を付けても、元の分岐は変更されません。
-  return state.destinations.map((dest) => ({
-    storage: dest.storage,
-    middlewares: [...dest.middlewares],
-  }));
-}
-
-/**
- * 分岐先を親の接頭辞付きで追加します。
- *
  * @param destinations 追加先の分岐先列です。
  * @param prefix 親のミドルウェア列です。
  * @param branch 追加する分岐です。
+ *
+ * @throws 分岐がストレージに到達しない場合に `InvalidForkError` を投げます。
  */
 export function appendForkDestinations(
   destinations: BranchDestination[],
   prefix: readonly UniKvsMiddleware[],
   branch: IUniKvsBranch,
 ): void {
+  const state = branchStates.get(branch);
+
+  if (!state) {
+    throw new TypeError("fork() expects a branch created by new Branch().");
+  }
+
+  if (state.destinations.length === 0) {
+    throw new InvalidForkError();
+  }
+
   const prefixSnapshot = [...prefix];
 
-  for (const dest of getBranchDestinationsForFork(branch)) {
+  for (const dest of state.destinations) {
     destinations.push({
       storage: dest.storage,
+      // コピーして追加します。親の fork で接頭辞を付けても、元の分岐は変更されません。
       // fork 時点の親チェーンを接頭辞として各分岐先の先頭に付け、ブランチのミドルウェアを結合します。
       middlewares: [...prefixSnapshot, ...dest.middlewares],
     });

package/src/_unikvs.schemas.ts

@@ -9,34 +9,20 @@ import type {
 } from "valibot";
 
 import type { VariablesEntry } from "./_contexts.js";
-import {
-  omit,
-  pipe,
-  tuple,
-  union,
-  custom,
-  object,
-  record,
-  string,
-  boolean,
-  unknown,
-  instance,
-  optional,
-  transform,
-} from "./_valibot.js";
+import * as v from "./_valibot.js";
 
-export const VariablesKeySchema: StringSchema<undefined> = string();
+export const VariablesKeySchema: StringSchema<undefined> = v.string();
 
-export const VariablesInitSchema: GenericSchema<any, readonly VariablesEntry[]> = pipe(
-  union([
-    custom<Iterable<VariablesEntry>>(
+export const VariablesInitSchema: GenericSchema<any, readonly VariablesEntry[]> = v.pipe(
+  v.union([
+    v.custom<Iterable<VariablesEntry>>(
       // 各アイテムの検証は今後の課題です。
       (input) => typeof input === "object" && input !== null && Symbol.iterator in input,
       "Expected a Iterable object",
     ),
-    record(VariablesKeySchema, unknown()),
+    v.record(VariablesKeySchema, v.unknown()),
   ]),
-  transform(
+  v.transform(
     (input: Iterable<VariablesEntry> | Record<string, unknown>): readonly VariablesEntry[] => {
       if (Symbol.iterator in input) {
         return [...input];
@@ -47,7 +33,7 @@ export const VariablesInitSchema: GenericSchema<any, readonly VariablesEntry[]>
   ),
 );
 
-export const VariablesArgsSchema: TupleSchema<[typeof VariablesInitSchema], undefined> = tuple([
+export const VariablesArgsSchema: TupleSchema<[typeof VariablesInitSchema], undefined> = v.tuple([
   VariablesInitSchema,
 ]);
 
@@ -57,22 +43,22 @@ export const OpenOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
+> = v.object({
   /**
    * 処理の中断を通知するためのシグナルです。
    */
-  signal: optional(instance(AbortSignal)),
+  signal: v.optional(v.instance(AbortSignal)),
 
   /**
    * 実行時の変数です。
    */
-  vars: optional(VariablesInitSchema),
+  vars: v.optional(VariablesInitSchema),
 });
 
 export const OpenArgsSchema: TupleSchema<
   [OptionalSchema<typeof OpenOptionsSchema, undefined>],
   undefined
-> = tuple([optional(OpenOptionsSchema)]);
+> = v.tuple([v.optional(OpenOptionsSchema)]);
 
 export const CloseOptionsSchema: ObjectSchema<
   {
@@ -80,22 +66,22 @@ export const CloseOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
+> = v.object({
   /**
    * 処理の中断を通知するためのシグナルです。
    */
-  signal: optional(instance(AbortSignal)),
+  signal: v.optional(v.instance(AbortSignal)),
 
   /**
    * 実行時の変数です。
    */
-  vars: optional(VariablesInitSchema),
+  vars: v.optional(VariablesInitSchema),
 });
 
 export const CloseArgsSchema: TupleSchema<
   [OptionalSchema<typeof CloseOptionsSchema, undefined>],
   undefined
-> = tuple([optional(CloseOptionsSchema)]);
+> = v.tuple([v.optional(CloseOptionsSchema)]);
 
 export const SetOptionsSchema: ObjectSchema<
   {
@@ -105,11 +91,11 @@ export const SetOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
-  key: string(),
-  vars: optional(VariablesInitSchema),
-  value: unknown(),
-  signal: optional(instance(AbortSignal)),
+> = v.object({
+  key: v.string(),
+  vars: v.optional(VariablesInitSchema),
+  value: v.unknown(),
+  signal: v.optional(v.instance(AbortSignal)),
 });
 
 export const SetArgsSchema: GenericSchema<
@@ -130,15 +116,15 @@ export const SetArgsSchema: GenericSchema<
         readonly signal?: AbortSignal | undefined;
       },
     ]
-> = union([
-  tuple([SetOptionsSchema]),
-  pipe(
-    tuple([
+> = v.union([
+  v.tuple([SetOptionsSchema]),
+  v.pipe(
+    v.tuple([
       SetOptionsSchema.entries.key,
       SetOptionsSchema.entries.value,
-      optional(omit(SetOptionsSchema, ["key", "value"])),
+      v.optional(v.omit(SetOptionsSchema, ["key", "value"])),
     ]),
-    transform(
+    v.transform(
       ([key, value, options]: [
         string,
         unknown,
@@ -176,12 +162,12 @@ export const GetOptionsSchema: ObjectSchema<
     readonly throwOnRepairDenied: OptionalSchema<BooleanSchema<undefined>, undefined>;
   },
   undefined
-> = object({
-  key: string(),
-  vars: optional(VariablesInitSchema),
-  repair: optional(boolean()),
-  signal: optional(instance(AbortSignal)),
-  throwOnRepairDenied: optional(boolean()),
+> = v.object({
+  key: v.string(),
+  vars: v.optional(VariablesInitSchema),
+  repair: v.optional(v.boolean()),
+  signal: v.optional(v.instance(AbortSignal)),
+  throwOnRepairDenied: v.optional(v.boolean()),
 });
 
 export const GetArgsSchema: GenericSchema<
@@ -204,11 +190,11 @@ export const GetArgsSchema: GenericSchema<
         readonly throwOnRepairDenied?: boolean | undefined;
       },
     ]
-> = union([
-  tuple([GetOptionsSchema]),
-  pipe(
-    tuple([GetOptionsSchema.entries.key, optional(omit(GetOptionsSchema, ["key"]))]),
-    transform(
+> = v.union([
+  v.tuple([GetOptionsSchema]),
+  v.pipe(
+    v.tuple([GetOptionsSchema.entries.key, v.optional(v.omit(GetOptionsSchema, ["key"]))]),
+    v.transform(
       ([key, options]: [
         string,
         (
@@ -247,12 +233,12 @@ export const StreamOptionsSchema: ObjectSchema<
     readonly throwOnRepairDenied: OptionalSchema<BooleanSchema<undefined>, undefined>;
   },
   undefined
-> = object({
-  key: string(),
-  vars: optional(VariablesInitSchema),
-  repair: optional(boolean()),
-  signal: optional(instance(AbortSignal)),
-  throwOnRepairDenied: optional(boolean()),
+> = v.object({
+  key: v.string(),
+  vars: v.optional(VariablesInitSchema),
+  repair: v.optional(v.boolean()),
+  signal: v.optional(v.instance(AbortSignal)),
+  throwOnRepairDenied: v.optional(v.boolean()),
 });
 
 export const StreamArgsSchema: GenericSchema<
@@ -275,11 +261,11 @@ export const StreamArgsSchema: GenericSchema<
         readonly throwOnRepairDenied?: boolean | undefined;
       },
     ]
-> = union([
-  tuple([StreamOptionsSchema]),
-  pipe(
-    tuple([StreamOptionsSchema.entries.key, optional(omit(StreamOptionsSchema, ["key"]))]),
-    transform(
+> = v.union([
+  v.tuple([StreamOptionsSchema]),
+  v.pipe(
+    v.tuple([StreamOptionsSchema.entries.key, v.optional(v.omit(StreamOptionsSchema, ["key"]))]),
+    v.transform(
       ([key, options]: [
         string,
         (
@@ -316,10 +302,10 @@ export const HasOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
-  key: string(),
-  vars: optional(VariablesInitSchema),
-  signal: optional(instance(AbortSignal)),
+> = v.object({
+  key: v.string(),
+  vars: v.optional(VariablesInitSchema),
+  signal: v.optional(v.instance(AbortSignal)),
 });
 
 export const HasArgsSchema: GenericSchema<
@@ -338,11 +324,11 @@ export const HasArgsSchema: GenericSchema<
         readonly signal?: AbortSignal | undefined;
       },
     ]
-> = union([
-  tuple([HasOptionsSchema]),
-  pipe(
-    tuple([HasOptionsSchema.entries.key, optional(omit(HasOptionsSchema, ["key"]))]),
-    transform(
+> = v.union([
+  v.tuple([HasOptionsSchema]),
+  v.pipe(
+    v.tuple([HasOptionsSchema.entries.key, v.optional(v.omit(HasOptionsSchema, ["key"]))]),
+    v.transform(
       ([key, options]: [
         string,
         (
@@ -375,10 +361,10 @@ export const DeleteOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
-  key: string(),
-  vars: optional(VariablesInitSchema),
-  signal: optional(instance(AbortSignal)),
+> = v.object({
+  key: v.string(),
+  vars: v.optional(VariablesInitSchema),
+  signal: v.optional(v.instance(AbortSignal)),
 });
 
 export const DeleteArgsSchema: GenericSchema<
@@ -397,11 +383,11 @@ export const DeleteArgsSchema: GenericSchema<
         readonly signal?: AbortSignal | undefined;
       },
     ]
-> = union([
-  tuple([DeleteOptionsSchema]),
-  pipe(
-    tuple([DeleteOptionsSchema.entries.key, optional(omit(DeleteOptionsSchema, ["key"]))]),
-    transform(
+> = v.union([
+  v.tuple([DeleteOptionsSchema]),
+  v.pipe(
+    v.tuple([DeleteOptionsSchema.entries.key, v.optional(v.omit(DeleteOptionsSchema, ["key"]))]),
+    v.transform(
       ([key, options]: [
         string,
         (
@@ -433,19 +419,19 @@ export const ClearOptionsSchema: ObjectSchema<
     readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
   },
   undefined
-> = object({
+> = v.object({
   /**
    * 処理の中断を通知するためのシグナルです。
    */
-  signal: optional(instance(AbortSignal)),
+  signal: v.optional(v.instance(AbortSignal)),
 
   /**
    * 実行時の変数です。
    */
-  vars: optional(VariablesInitSchema),
+  vars: v.optional(VariablesInitSchema),
 });
 
 export const ClearArgsSchema: TupleSchema<
   [OptionalSchema<typeof ClearOptionsSchema, undefined>],
   undefined
-> = tuple([optional(ClearOptionsSchema)]);
+> = v.tuple([v.optional(ClearOptionsSchema)]);

package/src/_value-schemas.ts

@@ -1,5 +1,4 @@
-import type { GenericSchema } from "./_valibot.js";
-import { union, safeParse } from "./_valibot.js";
+import * as v from "./_valibot.js";
 import { InvalidInputError } from "./errors.js";
 import type { PlainValue, StreamValue } from "./value-schemas.js";
 
@@ -71,7 +70,7 @@ export type ValueSchemaInfo = {
   /**
    * データの検証に使用するスキーマです。
    */
-  readonly schema: GenericSchema;
+  readonly schema: v.GenericSchema;
 };
 
 // -------------------------------------------------------------------------------------------------。
@@ -88,7 +87,7 @@ type UniKvsSchemaInfoRecord = Readonly<Record<string, ValueSchemaInfo>>;
 /**
  * 検証済みの配列形式のスキーマ定義です。
  */
-type UniKvsSchemaInfoEntries = readonly (readonly [GenericSchema, ValueSchemaInfo])[];
+type UniKvsSchemaInfoEntries = readonly (readonly [v.GenericSchema, ValueSchemaInfo])[];
 
 /**
  * 検証済みのスキーマ定義です。
@@ -140,12 +139,12 @@ class RecordValueSchemaResolver implements IValueSchemaResolver {
 class EntriesValueSchemaResolver implements IValueSchemaResolver {
   readonly #entries: UniKvsSchemaInfoEntries;
 
-  readonly #keySchema: GenericSchema | undefined;
+  readonly #keySchema: v.GenericSchema | undefined;
 
   public constructor(entries: UniKvsSchemaInfoEntries) {
     this.#entries = entries;
     if (entries.length > 0) {
-      this.#keySchema = union(entries.map(([keySchema]) => keySchema));
+      this.#keySchema = v.union(entries.map(([keySchema]) => keySchema));
     }
   }
 
@@ -153,7 +152,7 @@ class EntriesValueSchemaResolver implements IValueSchemaResolver {
     let resolved: ValueSchemaInfo | undefined;
 
     for (const [keySchema, valueSchema] of this.#entries) {
-      const result = safeParse(keySchema, key);
+      const result = v.safeParse(keySchema, key);
 
       if (result.success) {
         resolved = valueSchema;
@@ -162,7 +161,7 @@ class EntriesValueSchemaResolver implements IValueSchemaResolver {
     }
 
     if (resolved === undefined && this.#keySchema) {
-      const result = safeParse(this.#keySchema, key);
+      const result = v.safeParse(this.#keySchema, key);
 
       if (!result.success) {
         throw new InvalidInputError({

package/src/_value-validation.ts

@@ -1,13 +1,13 @@
 import { isReadableStream } from "./_streams.js";
-import { pipe, check, unknown, parseInput } from "./_valibot.js";
+import * as v from "./_valibot.js";
 import type { ValueSchemaInfo } from "./_value-schemas.js";
 
 /**
  * プレーン値専用のスキーマに ReadableStream が渡されたことを報告するためのスキーマです。
  */
-const PlainValueInputSchema = pipe(
-  unknown(),
-  check(
+const PlainValueInputSchema = v.pipe(
+  v.unknown(),
+  v.check(
     (input) => !isReadableStream(input),
     "Expected a plain value, but received a ReadableStream",
   ),
@@ -16,9 +16,9 @@ const PlainValueInputSchema = pipe(
 /**
  * ストリーム専用のスキーマにプレーン値が渡されたことを報告するためのスキーマです。
  */
-const StreamValueInputSchema = pipe(
-  unknown(),
-  check(isReadableStream, "Expected a ReadableStream, but received a plain value"),
+const StreamValueInputSchema = v.pipe(
+  v.unknown(),
+  v.check(isReadableStream, "Expected a ReadableStream, but received a plain value"),
 );
 
 /**
@@ -35,14 +35,14 @@ export function parseSetValue(info: ValueSchemaInfo, value: unknown): unknown {
   if (isReadableStream(value)) {
     if (info.kind === "plain") {
       // 必ず検証に失敗するため、InvalidInputError が投げられます。
-      parseInput(PlainValueInputSchema, value);
+      v.parseInput(PlainValueInputSchema, value);
     }
 
     // 入力チャンクを検証し、変換後の値を後続のパイプラインへ流します。
     return value.pipeThrough(
       new TransformStream({
         transform(chunk, controller) {
-          controller.enqueue(parseInput(info.schema, chunk));
+          controller.enqueue(v.parseInput(info.schema, chunk));
         },
       }),
     );
@@ -50,8 +50,8 @@ export function parseSetValue(info: ValueSchemaInfo, value: unknown): unknown {
 
   if (info.kind === "stream") {
     // 必ず検証に失敗するため、InvalidInputError が投げられます。
-    parseInput(StreamValueInputSchema, value);
+    v.parseInput(StreamValueInputSchema, value);
   }
 
-  return parseInput(info.schema, value);
+  return v.parseInput(info.schema, value);
 }