gloomberb 0.7.4 → 0.8.0

package/src/cli/pane-functions/index.ts

@@ -0,0 +1,112 @@
+import { extname, resolve } from "path";
+import type { CliCommandContext } from "../../types/plugin";
+import type { MarketContext } from "../types";
+import {
+  filterPaneCatalogEntries,
+  renderPaneCatalogReport,
+  type PaneFunctionCatalog,
+} from "./catalog";
+import { createPaneCatalog } from "./discovery";
+import {
+  normalizeLookupToken,
+  optionPaneState,
+  parseArgumentsOption,
+  parsePaneCatalogArgs,
+  parsePaneFunctionArgs,
+  type ParsedPaneFunctionArgs,
+} from "./options";
+import { resolvePaneFunction, type ResolvedPaneFunction } from "./resolver";
+import { buildFunctionReport } from "./report";
+import { defaultScreenshotPath, renderDesktopShot } from "./screenshot";
+import {
+  buildPaneCatalogEntries,
+} from "./catalog";
+
+async function withPaneRuntime<T>(
+  ctx: CliCommandContext,
+  args: string[],
+  run: (runtime: {
+    parsed: ParsedPaneFunctionArgs;
+    context: MarketContext;
+    registry: PaneFunctionCatalog;
+    resolved: ResolvedPaneFunction;
+  }) => Promise<T>,
+): Promise<T> {
+  const parsed = parsePaneFunctionArgs(args);
+  const context = await ctx.initMarketData();
+  const registry = await createPaneCatalog(context, ctx.plugins);
+  try {
+    const resolved = await resolvePaneFunction(registry, context, parsed);
+    return await run({ parsed, context, registry, resolved });
+  } finally {
+    registry.destroy();
+    context.persistence.close();
+  }
+}
+
+export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
+  await runPaneCliCommand(ctx, async () => {
+    await withPaneRuntime(ctx, args, async ({ parsed, context, resolved }) => {
+      const report = await buildFunctionReport(resolved, context, parsed.arg, parsed.options);
+      console.log(report);
+    });
+  });
+}
+
+export async function runPaneScreenshot(args: string[], ctx: CliCommandContext) {
+  await runPaneCliCommand(ctx, async () => {
+    await withPaneRuntime(ctx, args, async ({ parsed, context, resolved }) => {
+      const outputPath = parsed.outputPath
+        ? resolve(process.cwd(), ensurePngExtension(parsed.outputPath))
+        : defaultScreenshotPath(resolved, parsed.arg);
+      await renderDesktopShot({
+        resolved,
+        context,
+        rawArg: parsed.arg,
+        outputPath,
+        width: parsed.width,
+        height: parsed.height,
+        options: parsed.options,
+      });
+      console.log(`Saved screenshot to ${outputPath}`);
+    });
+  });
+}
+
+export async function runPaneCatalog(args: string[], ctx: CliCommandContext) {
+  await runPaneCliCommand(ctx, async () => {
+    const parsed = parsePaneCatalogArgs(args);
+    const context = await ctx.initMarketData();
+    const registry = await createPaneCatalog(context, ctx.plugins);
+    try {
+      const entries = await buildPaneCatalogEntries(registry, context);
+      console.log(renderPaneCatalogReport(filterPaneCatalogEntries(entries, parsed.query), parsed));
+    } finally {
+      registry.destroy();
+      context.persistence.close();
+    }
+  });
+}
+
+async function runPaneCliCommand(ctx: CliCommandContext, run: () => Promise<void>) {
+  try {
+    await run();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.fail(message);
+  }
+}
+
+function ensurePngExtension(path: string): string {
+  return extname(path) ? path : `${path}.png`;
+}
+
+export const paneFunctionTestInternals = {
+  parsePaneFunctionArgs,
+  parsePaneCatalogArgs,
+  normalizeLookupToken,
+  parseArgumentsOption,
+  optionPaneState,
+  filterPaneCatalogEntries,
+  renderPaneCatalogReport,
+};

package/src/cli/pane-functions/options.ts

@@ -0,0 +1,249 @@
+import type { PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import { parseTickerListInput } from "../../tickers/list";
+import { normalizeTickerInput } from "../../tickers/search";
+import {
+  FINANCIAL_SUB_TABS,
+  resolveFinancialPeriodOption,
+} from "../../plugins/builtin/ticker-detail/financials/model";
+import type { PaneRuntimeState } from "../../core/state/app/state";
+
+const DEFAULT_SHOT_WIDTH = 1280;
+const DEFAULT_SHOT_HEIGHT = 720;
+const MAX_SHOT_WIDTH = 2400;
+const MIN_SHOT_WIDTH = 720;
+const MAX_SHOT_HEIGHT = 1800;
+const MIN_SHOT_HEIGHT = 360;
+const DEFAULT_CATALOG_LIMIT = 25;
+
+export interface ParsedPaneFunctionArgs {
+  target: string;
+  arg: string;
+  options: Record<string, string | true>;
+  outputPath: string | null;
+  width: number;
+  height: number;
+}
+
+export interface ParsedPaneCatalogArgs {
+  query: string;
+  limit: number;
+}
+
+function normalizeOptionKey(value: string): string {
+  return value.trim().replace(/^-+/, "").replace(/[\s_-]+(.)/g, (_, char: string) => char.toUpperCase());
+}
+
+export function normalizeLookupToken(value: string): string {
+  return value.trim().replace(/^\$/, "").toLowerCase().replace(/[\s_-]+/g, "");
+}
+
+export function cleanTickerInput(value: string): string {
+  return value.trim().replace(/^\$/, "").toUpperCase();
+}
+
+export function parseArgumentsOption(value: string): Record<string, string> {
+  const pairs: Record<string, string> = {};
+  for (const part of value.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const equalsIndex = trimmed.indexOf("=");
+    if (equalsIndex === -1) continue;
+    pairs[normalizeOptionKey(trimmed.slice(0, equalsIndex))] = trimmed.slice(equalsIndex + 1).trim();
+  }
+  return pairs;
+}
+
+export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
+  const positionals: string[] = [];
+  const options: Record<string, string | true> = {};
+  let outputPath: string | null = null;
+  let width = DEFAULT_SHOT_WIDTH;
+  let height = DEFAULT_SHOT_HEIGHT;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--") {
+      positionals.push(...args.slice(index + 1));
+      break;
+    }
+
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const raw = token.slice(2);
+    const equalsIndex = raw.indexOf("=");
+    const key = equalsIndex >= 0 ? raw.slice(0, equalsIndex) : raw;
+    const inlineValue = equalsIndex >= 0 ? raw.slice(equalsIndex + 1) : undefined;
+    const next = args[index + 1];
+    const nextValue = next && !next.startsWith("--") ? args[++index] : true;
+    const value: string | true = inlineValue ?? nextValue ?? true;
+    const normalizedKey = normalizeOptionKey(key);
+    if (normalizedKey === "output" || normalizedKey === "out" || normalizedKey === "o") {
+      outputPath = value === true ? null : value;
+    } else if (normalizedKey === "width" && value !== true) {
+      const parsedWidth = Number(value);
+      if (Number.isFinite(parsedWidth)) {
+        width = Math.max(MIN_SHOT_WIDTH, Math.min(MAX_SHOT_WIDTH, Math.round(parsedWidth)));
+      }
+    } else if (normalizedKey === "height" && value !== true) {
+      const parsedHeight = Number(value);
+      if (Number.isFinite(parsedHeight)) {
+        height = Math.max(MIN_SHOT_HEIGHT, Math.min(MAX_SHOT_HEIGHT, Math.round(parsedHeight)));
+      }
+    } else if (normalizedKey === "arguments" && value !== true) {
+      Object.assign(options, parseArgumentsOption(value));
+    } else {
+      options[normalizedKey] = value;
+    }
+  }
+
+  const target = positionals[0]?.trim() ?? "";
+  const arg = positionals.slice(1).join(" ").trim();
+  return { target, arg, options, outputPath, width, height };
+}
+
+export function parsePaneCatalogArgs(args: string[]): ParsedPaneCatalogArgs {
+  const queryParts: string[] = [];
+  let limit = DEFAULT_CATALOG_LIMIT;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--") {
+      queryParts.push(...args.slice(index + 1));
+      break;
+    }
+
+    if (token === "--all") {
+      limit = Number.POSITIVE_INFINITY;
+      continue;
+    }
+
+    if (token === "--limit") {
+      const parsed = Number(args[++index]);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        limit = Math.max(1, Math.round(parsed));
+      }
+      continue;
+    }
+
+    if (token.startsWith("--limit=")) {
+      const parsed = Number(token.slice("--limit=".length));
+      if (Number.isFinite(parsed) && parsed > 0) {
+        limit = Math.max(1, Math.round(parsed));
+      }
+      continue;
+    }
+
+    queryParts.push(token);
+  }
+
+  return {
+    query: queryParts.join(" ").trim(),
+    limit,
+  };
+}
+
+export function optionString(options: Record<string, string | true>, key: string): string | undefined {
+  const value = options[normalizeOptionKey(key)];
+  return value === true ? undefined : value;
+}
+
+const RESERVED_OPTION_KEYS = new Set(["output", "out", "o", "width", "height", "arguments", "state"]);
+
+export function optionSettings(options: Record<string, string | true>): Record<string, unknown> {
+  const settings: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (RESERVED_OPTION_KEYS.has(key) || key.startsWith("state.")) continue;
+    settings[key] = value === true ? true : coerceSettingValue(value);
+  }
+  return settings;
+}
+
+function coerceSettingValue(value: string): unknown {
+  const trimmed = value.trim();
+  if (/^(true|false)$/i.test(trimmed)) return trimmed.toLowerCase() === "true";
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  return trimmed;
+}
+
+export function buildCreateOptions(
+  template: PaneTemplateDef | undefined,
+  arg: string,
+): PaneTemplateCreateOptions | undefined {
+  if (!template && !arg) return undefined;
+  const values: Record<string, string> = {};
+  const createOptions: PaneTemplateCreateOptions = arg ? { arg } : {};
+  const argPlaceholder = template?.shortcut?.argPlaceholder;
+  if (argPlaceholder && arg) values[argPlaceholder] = arg;
+
+  if (template?.shortcut?.argKind === "ticker") {
+    const symbol = normalizeTickerInput(null, cleanTickerInput(arg));
+    createOptions.symbol = symbol;
+    if (symbol) createOptions.arg = symbol;
+  } else if (template?.shortcut?.argKind === "ticker-list") {
+    const raw = arg.replace(/\$/g, "");
+    createOptions.arg = raw;
+    try {
+      createOptions.symbols = parseTickerListInput(raw);
+    } catch {
+      createOptions.symbols = raw
+        .split(",")
+        .map((entry) => cleanTickerInput(entry))
+        .filter(Boolean);
+    }
+  }
+
+  if (Object.keys(values).length > 0) createOptions.values = values;
+  return createOptions;
+}
+
+function normalizeFinancialSubTabOption(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase().replace(/[\s_-]+/g, "");
+  if (!normalized) return undefined;
+  if (normalized === "cf" || normalized === "cashflows") return "cashflow";
+  if (normalized === "bs" || normalized === "balancesheet") return "balance";
+  return FINANCIAL_SUB_TABS.find((tab) => (
+    tab.key.toLowerCase() === normalized
+    || tab.name.toLowerCase().replace(/[\s_-]+/g, "") === normalized
+  ))?.key;
+}
+
+export function optionPaneState(options: Record<string, string | true>): PaneRuntimeState {
+  const state: PaneRuntimeState = {};
+  const rawState = optionString(options, "state");
+  if (rawState) {
+    for (const [key, value] of Object.entries(parseArgumentsOption(rawState))) {
+      state[key] = coerceSettingValue(value);
+    }
+  }
+
+  for (const [key, value] of Object.entries(options)) {
+    if (!key.startsWith("state.") || value === true) continue;
+    state[key.slice("state.".length)] = coerceSettingValue(value);
+  }
+
+  const activeTab = optionString(options, "activeTabId")
+    ?? optionString(options, "activeTab")
+    ?? optionString(options, "paneTab");
+  if (activeTab) state.activeTabId = activeTab;
+
+  const tab = optionString(options, "tab");
+  const financialTab = normalizeFinancialSubTabOption(
+    optionString(options, "statement")
+      ?? optionString(options, "financialStatement")
+      ?? tab,
+  );
+  if (financialTab) {
+    state.financialSubTab = financialTab;
+  } else if (tab) {
+    state.activeTabId = tab;
+  }
+
+  const period = resolveFinancialPeriodOption(optionString(options, "period") ?? optionString(options, "financialPeriod"));
+  if (period) state.financialPeriod = period;
+
+  return state;
+}

package/src/cli/pane-functions/report.ts

@@ -0,0 +1,180 @@
+import type { TickerFinancials } from "../../types/financials";
+import { formatCurrency, formatNumber, formatPercentRaw } from "../../utils/format";
+import { formatTimestamp } from "../helpers";
+import { buildTickerReport } from "../commands/ticker";
+import { createBaseConverter } from "../base-converter";
+import type { MarketContext } from "../types";
+import {
+  buildFinancialTableModel,
+  formatFinancialHeader,
+  resolveFinancialPeriodOption,
+} from "../../plugins/builtin/ticker-detail/financials/model";
+import { optionString } from "./options";
+import type { ResolvedPaneFunction } from "./resolver";
+import {
+  fetchTickerFinancials,
+  isFinancialAnalysisFunction,
+  requireSymbol,
+} from "./data";
+
+function formatQuoteLine(financials: TickerFinancials): string {
+  const quote = financials.quote;
+  if (!quote) return "";
+  const change = `${quote.change >= 0 ? "+" : ""}${formatCurrency(quote.change, quote.currency)} (${formatPercentRaw(quote.changePercent)})`;
+  const parts = [
+    `${quote.symbol} ${quote.name ?? ""}`.trim(),
+    formatCurrency(quote.price, quote.currency),
+    change,
+    quote.marketCap != null ? `MCap ${formatNumber(quote.marketCap, 0)}` : "",
+    quote.lastUpdated ? `Updated ${formatTimestamp(quote.lastUpdated)}` : "",
+  ].filter(Boolean);
+  return parts.join(" | ");
+}
+
+async function buildFinancialStatementReport(
+  resolved: ResolvedPaneFunction,
+  context: MarketContext,
+  rawArg: string,
+  options: Record<string, string | true>,
+): Promise<string> {
+  const symbol = requireSymbol(resolved, rawArg);
+  const { tickerFile, financials } = await fetchTickerFinancials(context, symbol);
+  if (!financials.quote) throw new Error(`No quote data available for ${symbol}.`);
+  const table = buildFinancialTableModel(financials, {
+    period: resolveFinancialPeriodOption(optionString(options, "period")),
+    statement: optionString(options, "statement") ?? optionString(options, "tab"),
+  });
+  const name = financials.quote.name ?? tickerFile?.metadata.name ?? symbol;
+  const lines = [
+    `${financials.quote.symbol} ${name}`,
+    table
+      ? `Financial Statements | ${table.period === "annual" ? "Annual" : "Quarterly"} | ${table.subTab.name}`
+      : "Financial Statements",
+    financials.quote.currency ? `Currency ${financials.quote.currency}` : "",
+    "",
+  ].filter((line) => line !== "");
+  if (!table) {
+    lines.push(formatQuoteLine(financials));
+    lines.push("");
+    lines.push(`No financial statement rows are available for ${symbol} from the configured data providers.`);
+    return lines.join("\n");
+  }
+  const columns = [
+    { header: "Metric" },
+    ...table.statements.map((statement) => ({ header: formatFinancialHeader(statement.date).trim(), align: "right" as const })),
+  ];
+  const rows = table.rows.map((row) => [
+    row.unitLabel,
+    ...row.cells.map((cell) => `${cell.valueText.trim()}${cell.growthText.trim() ? ` ${cell.growthText.trim()}` : ""}`),
+  ]);
+  lines.push(contextOutputTable(columns, rows));
+
+  return lines.join("\n");
+}
+
+function contextOutputTable(
+  columns: Array<{ header: string; align?: "left" | "right" | "center" }>,
+  rows: string[][],
+): string {
+  const widths = columns.map((column, index) => Math.max(
+    column.header.length,
+    ...rows.map((row) => (row[index] ?? "").length),
+  ));
+  const renderRow = (cells: string[], header = false) => cells
+    .map((cell, index) => {
+      const align = columns[index]?.align ?? "left";
+      const width = widths[index] ?? cell.length;
+      const padding = Math.max(0, width - cell.length);
+      const text = align === "right" ? `${" ".repeat(padding)}${cell}` : `${cell}${" ".repeat(padding)}`;
+      return header ? text.toUpperCase() : text;
+    })
+    .join("  ");
+  return [
+    renderRow(columns.map((column) => column.header), true),
+    widths.map((width) => "-".repeat(width)).join("  "),
+    ...rows.map((row) => renderRow(row)),
+  ].join("\n");
+}
+
+async function buildTickerListReport(
+  resolved: ResolvedPaneFunction,
+  context: MarketContext,
+): Promise<string | null> {
+  const symbols = resolved.createOptions?.symbols;
+  if (!symbols?.length) return null;
+  const quotes = await Promise.all(symbols.map(async (symbol) => {
+    const quote = await context.dataProvider.getQuote(symbol);
+    return quote;
+  }));
+  const rows = quotes.map((quote) => [
+    quote.symbol,
+    quote.name ?? "",
+    formatCurrency(quote.price, quote.currency),
+    `${quote.change >= 0 ? "+" : ""}${formatCurrency(quote.change, quote.currency)}`,
+    formatPercentRaw(quote.changePercent),
+  ]);
+  return [
+    `${resolved.label} | ${symbols.join(", ")}`,
+    "",
+    contextOutputTable([
+      { header: "Ticker" },
+      { header: "Name" },
+      { header: "Last", align: "right" },
+      { header: "Change", align: "right" },
+      { header: "Change %", align: "right" },
+    ], rows),
+  ].join("\n");
+}
+
+export async function buildFunctionReport(
+  resolved: ResolvedPaneFunction,
+  context: MarketContext,
+  rawArg: string,
+  options: Record<string, string | true>,
+): Promise<string> {
+  if (isFinancialAnalysisFunction(resolved)) {
+    return buildFinancialStatementReport(resolved, context, rawArg, options);
+  }
+
+  if (resolved.template?.shortcut?.argKind === "ticker-list") {
+    const report = await buildTickerListReport(resolved, context);
+    if (report) return report;
+  }
+
+  if (resolved.template?.shortcut?.argKind === "ticker") {
+    const symbol = requireSymbol(resolved, rawArg);
+    const { tickerFile, financials } = await fetchTickerFinancials(context, symbol);
+    if (!financials.quote) throw new Error(`No quote data available for ${symbol}.`);
+    const toBase = createBaseConverter(context.dataProvider, context.config.baseCurrency);
+    return buildTickerReport({
+      symbol,
+      tickerFile,
+      financials,
+      config: context.config,
+      toBase,
+    });
+  }
+
+  return buildPaneDescriptionReport(resolved, rawArg);
+}
+
+function buildPaneDescriptionReport(resolved: ResolvedPaneFunction, rawArg: string): string {
+  const lines = [
+    `${resolved.label}`,
+    resolved.description,
+    "",
+    `Pane: ${resolved.pane.id} (${resolved.pane.name})`,
+  ];
+  if (resolved.template) lines.push(`Template: ${resolved.template.id}`);
+  if (resolved.shortcut) lines.push(`Shortcut: ${resolved.shortcut}`);
+  if (rawArg) lines.push(`Argument: ${rawArg}`);
+  const settingsEntries = Object.entries(resolved.instance.settings ?? {});
+  if (settingsEntries.length > 0) {
+    lines.push("");
+    lines.push("Settings:");
+    for (const [key, value] of settingsEntries) {
+      lines.push(`  ${key}: ${String(value)}`);
+    }
+  }
+  return lines.join("\n");
+}

package/src/cli/pane-functions/resolver.ts

@@ -0,0 +1,96 @@
+import type { PaneInstanceConfig } from "../../types/config";
+import type { PaneDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import { normalizeTickerInput } from "../../tickers/search";
+import { slugifyName } from "../../utils/slugify";
+import type { MarketContext } from "../types";
+import {
+  buildPaneFunctionLookup,
+  buildTemplateContext,
+  type PaneFunctionCatalog,
+} from "./catalog";
+import {
+  buildCreateOptions,
+  cleanTickerInput,
+  normalizeLookupToken,
+  optionSettings,
+  type ParsedPaneFunctionArgs,
+} from "./options";
+
+export interface ResolvedPaneFunction {
+  token: string;
+  label: string;
+  description: string;
+  shortcut?: string;
+  pane: PaneDef;
+  template?: PaneTemplateDef;
+  instance: PaneInstanceConfig;
+  createOptions: PaneTemplateCreateOptions | undefined;
+  optionSettings: Record<string, unknown>;
+}
+
+async function buildPaneInstance(
+  resolved: Pick<ResolvedPaneFunction, "pane" | "template" | "createOptions" | "optionSettings">,
+  context: MarketContext,
+  target: string,
+): Promise<PaneInstanceConfig> {
+  const primarySymbol = resolved.createOptions?.symbol
+    ?? resolved.createOptions?.symbols?.[0]
+    ?? normalizeTickerInput(null, cleanTickerInput(target));
+  const templateContext = buildTemplateContext(context, primarySymbol ?? null);
+  const spec = await resolved.template?.createInstance?.(templateContext, resolved.createOptions) ?? {};
+  const instanceId = `${resolved.pane.id}:cli-${slugifyName(target || resolved.pane.id, "pane")}`;
+  return {
+    instanceId,
+    paneId: resolved.pane.id,
+    title: spec.title ?? primarySymbol ?? resolved.pane.name,
+    binding: spec.binding ?? (primarySymbol ? { kind: "fixed", symbol: primarySymbol } : { kind: "none" }),
+    params: spec.params,
+    settings: {
+      ...spec.settings,
+      ...resolved.optionSettings,
+    },
+  };
+}
+
+export async function resolvePaneFunction(
+  registry: PaneFunctionCatalog,
+  context: MarketContext,
+  args: ParsedPaneFunctionArgs,
+): Promise<ResolvedPaneFunction> {
+  if (!args.target) {
+    throw new Error("Usage: gloomberb fn <function-or-pane> [argument] [--key value]");
+  }
+
+  const lookup = buildPaneFunctionLookup(registry);
+  const entry = lookup.get(normalizeLookupToken(args.target));
+  if (!entry) {
+    const shortcuts = [...registry.paneTemplates.values()]
+      .map((template) => template.shortcut?.prefix)
+      .filter((prefix): prefix is string => !!prefix)
+      .sort();
+    throw new Error(`Unknown function or pane "${args.target}". Try one of: ${shortcuts.slice(0, 18).join(", ")}`);
+  }
+
+  const settings = optionSettings(args.options);
+  const template = "paneId" in entry && "description" in entry ? entry as PaneTemplateDef : undefined;
+  const pane = template
+    ? registry.panes.get(template.paneId)
+    : entry as PaneDef;
+  if (!pane) {
+    throw new Error(`Template "${template?.id}" points at missing pane "${template?.paneId}".`);
+  }
+  const createOptions = buildCreateOptions(template, args.arg);
+  const resolved: ResolvedPaneFunction = {
+    token: template?.shortcut?.prefix ?? template?.id ?? pane.id,
+    label: template?.label ?? pane.name,
+    description: template?.description ?? `Open the ${pane.name} pane.`,
+    shortcut: template?.shortcut?.prefix,
+    pane,
+    template,
+    instance: {} as PaneInstanceConfig,
+    createOptions,
+    optionSettings: settings,
+  };
+  resolved.instance = await buildPaneInstance(resolved, context, args.arg || pane.id);
+  return resolved;
+}