just-bash-util 0.1.0

package/dist/chunk-OLDCCFR6.js

@@ -0,0 +1,793 @@
+// src/command/builders/option.ts
+var OptionBuilder = class _OptionBuilder {
+  /** @internal */
+  _def;
+  constructor(def) {
+    this._def = def;
+  }
+  /** Add a description */
+  describe(text) {
+    return new _OptionBuilder({ ...this._def, description: text });
+  }
+  /** Set a short alias (single character) */
+  short(alias) {
+    return new _OptionBuilder({ ...this._def, short: alias });
+  }
+  /** Set an environment variable fallback */
+  env(name) {
+    return new _OptionBuilder({ ...this._def, env: name });
+  }
+  /** Mark as required — removes undefined from TOut */
+  required() {
+    return new _OptionBuilder({
+      ...this._def,
+      required: true
+    });
+  }
+  /** Set a default value — removes undefined from TOut */
+  default(value) {
+    return new _OptionBuilder({
+      ...this._def,
+      default: value
+    });
+  }
+};
+function createOption(type) {
+  return new OptionBuilder({
+    _kind: "option",
+    type
+  });
+}
+function string() {
+  return createOption("string");
+}
+function number() {
+  return createOption("number");
+}
+
+// src/command/builders/flag.ts
+var FlagBuilder = class _FlagBuilder {
+  /** @internal */
+  _def;
+  constructor(def = { _kind: "flag" }) {
+    this._def = def;
+  }
+  /** Add a description */
+  describe(text) {
+    return new _FlagBuilder({ ...this._def, description: text });
+  }
+  /** Set a short alias (single character) */
+  short(alias) {
+    return new _FlagBuilder({ ...this._def, short: alias });
+  }
+  /** Set a default value */
+  default(value) {
+    return new _FlagBuilder({ ...this._def, default: value });
+  }
+};
+
+// src/command/builders/arg.ts
+var ArgBuilder = class _ArgBuilder {
+  /** @internal */
+  _def;
+  constructor(def) {
+    this._def = def;
+  }
+  /** Set the positional arg name (used for named access in the handler) */
+  name(name) {
+    return new _ArgBuilder({
+      ...this._def,
+      name
+    });
+  }
+  /** Add a description */
+  describe(text) {
+    return new _ArgBuilder({ ...this._def, description: text });
+  }
+  /** Mark as optional — adds undefined to TOut */
+  optional() {
+    return new _ArgBuilder({
+      ...this._def,
+      required: false
+    });
+  }
+  /** Mark as variadic — collects all remaining positionals into an array */
+  variadic() {
+    return new _ArgBuilder({
+      ...this._def,
+      variadic: true
+    });
+  }
+  /** Set a default value (also makes the arg optional at parse time) */
+  default(value) {
+    return new _ArgBuilder({
+      ...this._def,
+      required: false,
+      default: value
+    });
+  }
+};
+function createArg(type) {
+  return new ArgBuilder({
+    _kind: "arg",
+    type,
+    required: true
+  });
+}
+function string2() {
+  return createArg("string");
+}
+function number2() {
+  return createArg("number");
+}
+
+// src/command/builders/index.ts
+var o = {
+  string,
+  number
+};
+function f() {
+  return new FlagBuilder();
+}
+var a = {
+  string: string2,
+  number: number2
+};
+
+// src/command/errors.ts
+function formatError(error) {
+  switch (error.type) {
+    case "unknown_option": {
+      let msg = `Unknown option "${error.name}".`;
+      if (error.suggestions.length > 0) {
+        msg += ` Did you mean ${error.suggestions.map((s) => `"${s}"`).join(" or ")}?`;
+      }
+      return msg;
+    }
+    case "invalid_type":
+      return `Invalid value for "${error.name}": expected ${error.expected}, got "${error.received}".`;
+    case "missing_required":
+      return error.kind === "option" ? `Missing required option "--${error.name}".` : `Missing required argument <${error.name}>.`;
+    case "unexpected_positional":
+      return error.maxPositionals === 0 ? `Unexpected argument "${error.value}". This command takes no positional arguments.` : `Unexpected argument "${error.value}". Expected at most ${error.maxPositionals} positional argument${error.maxPositionals === 1 ? "" : "s"}.`;
+    case "missing_value":
+      return `Option "--${error.name}" requires a value.`;
+    case "unknown_command": {
+      let msg = `Unknown command "${error.path}".`;
+      if (error.suggestions.length > 0) {
+        msg += ` Did you mean ${error.suggestions.map((s) => `"${s}"`).join(" or ")}?`;
+      }
+      return msg;
+    }
+  }
+}
+function formatErrors(errors) {
+  return errors.map(formatError).join("\n");
+}
+function levenshtein(a2, b) {
+  const m = a2.length;
+  const n = b.length;
+  const dp = new Array((m + 1) * (n + 1));
+  for (let i = 0; i <= m; i++) dp[i * (n + 1)] = i;
+  for (let j = 0; j <= n; j++) dp[j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a2[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i * (n + 1) + j] = Math.min(
+        dp[(i - 1) * (n + 1) + j] + 1,
+        dp[i * (n + 1) + (j - 1)] + 1,
+        dp[(i - 1) * (n + 1) + (j - 1)] + cost
+      );
+    }
+  }
+  return dp[m * (n + 1) + n];
+}
+function findSuggestions(input, candidates, maxDistance = 3) {
+  const scored = candidates.map((c) => ({ candidate: c, distance: levenshtein(input, c) })).filter((x) => x.distance <= maxDistance && x.distance > 0).sort((a2, b) => a2.distance - b.distance);
+  return scored.slice(0, 2).map((x) => x.candidate);
+}
+
+// src/command/parser.ts
+function parseArgs(options, argDefs, tokens, env) {
+  const errors = [];
+  const longMap = /* @__PURE__ */ new Map();
+  const shortMap = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(options)) {
+    const longName = camelToKebab(key);
+    longMap.set(longName, { key, def });
+    if (def.short) {
+      shortMap.set(def.short, { key, def });
+    }
+  }
+  const result = {};
+  const positionals = [];
+  const passthrough = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token === "--") {
+      i++;
+      while (i < tokens.length) {
+        passthrough.push(tokens[i]);
+        i++;
+      }
+      break;
+    }
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      let longName;
+      let inlineValue;
+      if (eqIdx !== -1) {
+        longName = token.slice(2, eqIdx);
+        inlineValue = token.slice(eqIdx + 1);
+      } else {
+        longName = token.slice(2);
+      }
+      const entry = longMap.get(longName);
+      if (!entry) {
+        if (longName.startsWith("no-")) {
+          const positiveEntry = longMap.get(longName.slice(3));
+          if (positiveEntry && positiveEntry.def._kind === "flag") {
+            result[positiveEntry.key] = false;
+            i++;
+            continue;
+          }
+        }
+        const allLongNames = [...longMap.keys()];
+        errors.push({
+          type: "unknown_option",
+          name: `--${longName}`,
+          suggestions: findSuggestions(longName, allLongNames).map((s) => `--${s}`)
+        });
+        i++;
+        continue;
+      }
+      if (entry.def._kind === "flag") {
+        result[entry.key] = true;
+        i++;
+        continue;
+      }
+      const rawValue = inlineValue ?? tokens[++i];
+      if (rawValue === void 0) {
+        errors.push({ type: "missing_value", name: entry.key });
+        i++;
+        continue;
+      }
+      const parsed = coerce(rawValue, entry.def.type, entry.key, errors);
+      if (parsed !== void 0) {
+        result[entry.key] = parsed;
+      }
+      i++;
+      continue;
+    }
+    if (token.startsWith("-") && token.length > 1) {
+      const chars = token.slice(1);
+      for (let j = 0; j < chars.length; j++) {
+        const ch = chars[j];
+        const entry = shortMap.get(ch);
+        if (!entry) {
+          errors.push({
+            type: "unknown_option",
+            name: `-${ch}`,
+            suggestions: []
+          });
+          continue;
+        }
+        if (entry.def._kind === "flag") {
+          result[entry.key] = true;
+          continue;
+        }
+        const restOfString = chars.slice(j + 1);
+        const rawValue = restOfString.length > 0 ? restOfString : tokens[++i];
+        if (rawValue === void 0) {
+          errors.push({ type: "missing_value", name: entry.key });
+          break;
+        }
+        const parsed = coerce(rawValue, entry.def.type, entry.key, errors);
+        if (parsed !== void 0) {
+          result[entry.key] = parsed;
+        }
+        break;
+      }
+      i++;
+      continue;
+    }
+    positionals.push(token);
+    i++;
+  }
+  let posIdx = 0;
+  for (let idx = 0; idx < argDefs.length; idx++) {
+    const argDef = argDefs[idx];
+    const argName = argDef.name ?? `arg${idx}`;
+    if (argDef.variadic) {
+      const values = positionals.slice(posIdx);
+      if (values.length > 0) {
+        result[argName] = values.map((v) => coerce(v, argDef.type, argName, errors));
+      } else if (argDef.required) {
+        errors.push({ type: "missing_required", name: argName, kind: "arg" });
+      } else if (argDef.default !== void 0) {
+        result[argName] = argDef.default;
+      }
+      posIdx = positionals.length;
+    } else {
+      const value = positionals[posIdx];
+      if (value !== void 0) {
+        result[argName] = coerce(value, argDef.type, argName, errors);
+        posIdx++;
+      } else if (argDef.required) {
+        errors.push({ type: "missing_required", name: argName, kind: "arg" });
+      } else if (argDef.default !== void 0) {
+        result[argName] = argDef.default;
+      }
+    }
+  }
+  if (posIdx < positionals.length) {
+    for (let j = posIdx; j < positionals.length; j++) {
+      errors.push({
+        type: "unexpected_positional",
+        value: positionals[j],
+        maxPositionals: argDefs.length
+      });
+    }
+  }
+  for (const [key, def] of Object.entries(options)) {
+    if (result[key] === void 0) {
+      if (def._kind === "flag") {
+        result[key] = def.default ?? false;
+      } else if (def._kind === "option") {
+        const opt = def;
+        if (opt.env && env?.[opt.env] !== void 0) {
+          const parsed = coerce(env[opt.env], opt.type, key, errors);
+          if (parsed !== void 0) {
+            result[key] = parsed;
+          }
+        }
+        if (result[key] === void 0) {
+          if (opt.required && opt.default === void 0) {
+            errors.push({ type: "missing_required", name: key, kind: "option" });
+          } else if (opt.default !== void 0) {
+            result[key] = opt.default;
+          }
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return { ok: true, args: result, passthrough };
+}
+function coerce(raw, type, key, errors) {
+  switch (type) {
+    case "string":
+      return raw;
+    case "number": {
+      const n = Number(raw);
+      if (isNaN(n)) {
+        errors.push({ type: "invalid_type", name: key, expected: "number", received: raw });
+        return void 0;
+      }
+      return n;
+    }
+    case "boolean": {
+      if (raw === "true" || raw === "1") return true;
+      if (raw === "false" || raw === "0") return false;
+      errors.push({ type: "invalid_type", name: key, expected: "boolean", received: raw });
+      return void 0;
+    }
+    default:
+      return raw;
+  }
+}
+function camelToKebab(str) {
+  return str.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+
+// src/command/help.ts
+function generateHelp(cmd) {
+  const lines = [];
+  const hasSubcommands = cmd.children.size > 0;
+  if (cmd.description) {
+    lines.push(`${cmd.fullPath} - ${cmd.description}`);
+  } else {
+    lines.push(cmd.fullPath);
+  }
+  lines.push("");
+  const usageParts = [cmd.fullPath];
+  if (hasSubcommands) {
+    usageParts.push("<command>");
+  }
+  const allOptions = { ...cmd.inheritedOptions, ...cmd.options };
+  if (Object.keys(allOptions).length > 0) {
+    usageParts.push("[options]");
+  }
+  const argDefs = cmd.args;
+  for (const argDef of argDefs) {
+    const argName = argDef.name ?? "arg";
+    const label = argDef.variadic ? `${argName}...` : argName;
+    usageParts.push(argDef.required ? `<${label}>` : `[${label}]`);
+  }
+  lines.push("Usage:");
+  lines.push(`  ${usageParts.join(" ")}`);
+  lines.push("");
+  if (hasSubcommands) {
+    lines.push("Commands:");
+    const entries = [];
+    for (const [name, child] of cmd.children) {
+      entries.push([name, child.description || ""]);
+    }
+    const maxNameLen = Math.max(...entries.map(([name]) => name.length));
+    for (const [name, desc] of entries) {
+      const padding = " ".repeat(maxNameLen - name.length + 2);
+      lines.push(`  ${name}${padding}${desc}`);
+    }
+    lines.push("");
+  }
+  if (argDefs.length > 0) {
+    lines.push("Arguments:");
+    const argRows = [];
+    for (const argDef of argDefs) {
+      const rawName = argDef.name ?? "arg";
+      const label = argDef.variadic ? `${rawName}...` : rawName;
+      const parts = [];
+      if (argDef.description) parts.push(argDef.description);
+      if (argDef.required) parts.push("(required)");
+      if (argDef.default !== void 0) {
+        parts.push(`(default: ${JSON.stringify(argDef.default)})`);
+      }
+      argRows.push([label, parts.join(" ")]);
+    }
+    const maxLen = Math.max(...argRows.map(([label]) => label.length));
+    for (const [label, desc] of argRows) {
+      const padding = " ".repeat(maxLen - label.length + 2);
+      lines.push(`  ${label}${padding}${desc}`);
+    }
+    lines.push("");
+  }
+  const ownOptLines = formatOptionsTable(cmd.options);
+  if (ownOptLines.length > 0) {
+    lines.push("Options:");
+    lines.push(...ownOptLines);
+    lines.push("");
+  }
+  const inheritedOptLines = formatOptionsTable(cmd.inheritedOptions, "Inherited Options:");
+  if (inheritedOptLines.length > 0) {
+    lines.push(...inheritedOptLines);
+    lines.push("");
+  }
+  if (cmd.examples.length > 0) {
+    lines.push("Examples:");
+    for (const ex of cmd.examples) {
+      lines.push(`  ${ex}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatOptionsTable(schema, header) {
+  const entries = Object.entries(schema);
+  if (entries.length === 0) return [];
+  const rows = [];
+  for (const [key, def] of entries) {
+    const longName = camelToKebab(key);
+    if (def._kind === "flag") {
+      const flag = def;
+      const parts = [];
+      if (flag.short) parts.push(`-${flag.short},`);
+      parts.push(`--${longName}`);
+      const descParts = [];
+      if (flag.description) descParts.push(flag.description);
+      if (flag.default !== void 0) descParts.push(`(default: ${flag.default})`);
+      rows.push([parts.join(" "), descParts.join(" ")]);
+    } else {
+      const opt = def;
+      const parts = [];
+      if (opt.short) parts.push(`-${opt.short},`);
+      parts.push(`--${longName} <${opt.type}>`);
+      const descParts = [];
+      if (opt.description) descParts.push(opt.description);
+      if (opt.required) descParts.push("(required)");
+      if (opt.default !== void 0) descParts.push(`(default: ${JSON.stringify(opt.default)})`);
+      if (opt.env) descParts.push(`[env: ${opt.env}]`);
+      rows.push([parts.join(" "), descParts.join(" ")]);
+    }
+  }
+  const maxFlagLen = Math.max(...rows.map(([flag]) => flag.length));
+  const lines = [];
+  if (header) {
+    lines.push(header);
+  }
+  for (const [flag, desc] of rows) {
+    const padding = " ".repeat(maxFlagLen - flag.length + 2);
+    lines.push(`  ${flag}${padding}${desc}`);
+  }
+  return lines;
+}
+
+// src/command/command.ts
+function resolveOptionsInput(input) {
+  if (!input) return {};
+  const result = {};
+  for (const [key, builder] of Object.entries(input)) {
+    result[key] = builder._def;
+  }
+  return result;
+}
+function resolveArgsInput(input) {
+  if (!input) return [];
+  return input.map((builder) => builder._def);
+}
+var Command = class _Command {
+  name;
+  description;
+  options;
+  args;
+  examples;
+  omitInherited;
+  handler;
+  children = /* @__PURE__ */ new Map();
+  parent;
+  /** @internal — accumulated builder types for generic inference */
+  _accOpts;
+  /** @internal — args builder types for generic inference */
+  _accArgs;
+  /** @internal */
+  constructor(name, description, options, args, examples, omitInherited, handler, accOpts, accArgs) {
+    this.name = name;
+    this.description = description;
+    this.options = options;
+    this.args = args;
+    this.examples = examples;
+    this.omitInherited = omitInherited;
+    this.handler = handler;
+    this._accOpts = accOpts;
+    this._accArgs = accArgs;
+  }
+  // --------------------------------------------------------------------------
+  // Tree building
+  // --------------------------------------------------------------------------
+  /** Add a subcommand. Returns the child command for further nesting. */
+  command(name, config) {
+    const omitSet = new Set(config.omitInherited ?? []);
+    const parentAcc = { ...this._accOpts };
+    for (const key of omitSet) delete parentAcc[key];
+    const accOpts = { ...parentAcc, ...config.options ?? {} };
+    const child = new _Command(
+      name,
+      config.description,
+      resolveOptionsInput(config.options),
+      resolveArgsInput(config.args),
+      config.examples ?? [],
+      omitSet,
+      config.handler,
+      accOpts,
+      config.args ?? []
+    );
+    child.parent = this;
+    this.children.set(name, child);
+    return child;
+  }
+  // --------------------------------------------------------------------------
+  // Computed properties
+  // --------------------------------------------------------------------------
+  /** Full path from root (e.g. "mycli db migrate") */
+  get fullPath() {
+    const segments = [];
+    let current = this;
+    while (current) {
+      segments.unshift(current.name);
+      current = current.parent;
+    }
+    return segments.join(" ");
+  }
+  /**
+   * Return a plain `{ name, execute }` object compatible with just-bash's
+   * `CustomCommand` interface, with `execute` pre-bound to this command tree.
+   *
+   * @example
+   * ```ts
+   * const bash = new Bash({ customCommands: [mycli.toCommand()] });
+   * ```
+   */
+  toCommand() {
+    return { name: this.name, execute: this.execute.bind(this) };
+  }
+  /** Options inherited from ancestor commands */
+  get inheritedOptions() {
+    const inherited = {};
+    const chain = [];
+    let current = this;
+    while (current) {
+      chain.unshift(current);
+      current = current.parent;
+    }
+    for (const cmd of chain) {
+      for (const key of cmd.omitInherited) {
+        delete inherited[key];
+      }
+      if (cmd !== this) {
+        Object.assign(inherited, cmd.options);
+      }
+    }
+    return inherited;
+  }
+  /** All options available to this command (inherited + own) */
+  get allOptions() {
+    return { ...this.inheritedOptions, ...this.options };
+  }
+  // --------------------------------------------------------------------------
+  // Programmatic invocation
+  // --------------------------------------------------------------------------
+  /**
+   * Serialize a typed args object into CLI tokens.
+   *
+   * Produces tokens that, when parsed, reproduce the given args.
+   * Useful for building commands to pass to `execute()` or composing
+   * with `fullPath` for string-based execution.
+   *
+   * Only explicitly-provided values are serialized — omit a key to let
+   * the parser apply its default or env fallback as usual.
+   *
+   * @example
+   * ```ts
+   * const tokens = serve.toTokens({ port: 8080, entry: "app.ts" });
+   * await cli.execute(["serve", ...tokens], ctx);
+   * ```
+   */
+  toTokens(args) {
+    const tokens = [];
+    const allOpts = this.allOptions;
+    const input = args;
+    for (const [key, def] of Object.entries(allOpts)) {
+      const value = input[key];
+      const kebab = camelToKebab(key);
+      if (def._kind === "flag") {
+        if (value === true) {
+          tokens.push(`--${kebab}`);
+        } else if (value === false && def.default === true) {
+          tokens.push(`--no-${kebab}`);
+        }
+      } else if (def._kind === "option") {
+        if (value !== void 0) {
+          tokens.push(`--${kebab}`, String(value));
+        }
+      }
+    }
+    for (const argDef of this.args) {
+      const argName = argDef.name ?? "arg";
+      const value = input[argName];
+      if (value === void 0) continue;
+      if (argDef.variadic && Array.isArray(value)) {
+        for (const v of value) {
+          tokens.push(String(v));
+        }
+      } else {
+        tokens.push(String(value));
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Call this command's handler directly with typed args.
+   *
+   * Required options (no default) and required positional args must be
+   * provided. Options with defaults, flags, and optional args can be
+   * omitted — invoke applies their defaults automatically.
+   *
+   * @example
+   * ```ts
+   * const result = await serve.invoke({ port: 8080, entry: "app.ts" }, ctx);
+   * ```
+   */
+  async invoke(args, ctx) {
+    if (!this.handler) {
+      return {
+        stdout: "",
+        stderr: `Command "${this.fullPath}" has no handler`,
+        exitCode: 1
+      };
+    }
+    const resolved = { ...args };
+    const allOpts = this.allOptions;
+    for (const [key, def] of Object.entries(allOpts)) {
+      if (resolved[key] === void 0) {
+        if (def._kind === "flag") {
+          resolved[key] = def.default ?? false;
+        } else if (def._kind === "option") {
+          if (def.default !== void 0) {
+            resolved[key] = def.default;
+          } else if (def.required) {
+            return {
+              stdout: "",
+              stderr: `Missing required option "${key}"`,
+              exitCode: 1
+            };
+          }
+        }
+      }
+    }
+    for (const argDef of this.args) {
+      const argName = argDef.name ?? "arg";
+      if (resolved[argName] === void 0) {
+        if (argDef.default !== void 0) {
+          resolved[argName] = argDef.default;
+        } else if (argDef.required) {
+          return {
+            stdout: "",
+            stderr: `Missing required arg "${argName}"`,
+            exitCode: 1
+          };
+        }
+      }
+    }
+    return this.handler(resolved, ctx, { passthrough: [] });
+  }
+  // --------------------------------------------------------------------------
+  // Execution
+  // --------------------------------------------------------------------------
+  /**
+   * Execute this command tree with the given tokens.
+   *
+   * Tokens flow through the tree: each level consumes the subcommand name
+   * and passes the rest deeper. When no subcommand matches, the current
+   * node either parses and runs its handler, or returns help/error.
+   */
+  async execute(tokens, ctx) {
+    const env = ctx?.env ? Object.fromEntries(ctx.env) : {};
+    const firstToken = tokens[0];
+    if (firstToken && !firstToken.startsWith("-") && this.children.has(firstToken)) {
+      return this.children.get(firstToken).execute(tokens.slice(1), ctx);
+    }
+    if (hasHelpFlag(tokens)) {
+      return { stdout: generateHelp(this), stderr: "", exitCode: 0 };
+    }
+    if (this.handler) {
+      const parsed = parseArgs(this.allOptions, this.args, [...tokens], env);
+      if (!parsed.ok) {
+        return { stdout: "", stderr: formatErrors(parsed.errors), exitCode: 1 };
+      }
+      return this.handler(parsed.args, ctx, { passthrough: parsed.passthrough });
+    }
+    if (firstToken && !firstToken.startsWith("-")) {
+      const suggestions = findSuggestions(firstToken, [...this.children.keys()]);
+      return {
+        stdout: "",
+        stderr: formatErrors([{
+          type: "unknown_command",
+          path: `${this.fullPath} ${firstToken}`,
+          suggestions
+        }]),
+        exitCode: 1
+      };
+    }
+    return { stdout: generateHelp(this), stderr: "", exitCode: 0 };
+  }
+};
+function command(name, config) {
+  return new Command(
+    name,
+    config.description,
+    resolveOptionsInput(config.options),
+    resolveArgsInput(config.args),
+    config.examples ?? [],
+    /* @__PURE__ */ new Set(),
+    config.handler,
+    config.options ?? {},
+    config.args ?? []
+  );
+}
+function hasHelpFlag(tokens) {
+  return tokens.some((t) => t === "--help" || t === "-h");
+}
+
+export {
+  o,
+  f,
+  a,
+  formatError,
+  formatErrors,
+  parseArgs,
+  generateHelp,
+  Command,
+  command
+};