@sarjallab09/figma-intelligence 1.0.1 → 1.2.0

package/figma-intelligence-layer/src/shared/vision-client.ts

@@ -1,607 +0,0 @@
-import {
-  VisionResult,
-  LayoutZone,
-  LayoutNode,
-  LayoutNodeAlignment,
-  LayoutNodeType,
-  ComponentManifest,
-} from "./types.js";
-import { OpenAIVisionProvider } from "./vision-provider-openai.js";
-import { AnthropicVisionProvider } from "./vision-provider-anthropic.js";
-
-const DEFAULT_MANIFEST: ComponentManifest = {
-  componentType: "Unknown",
-  variants: {},
-  iconPresent: false,
-  iconKind: "unknown",
-  preferredIconLibrary: "material-symbols",
-  interactiveElement: false,
-  estimatedSpacing: 8,
-  confidence: 0.3,
-};
-
-function clampConfidence(value: unknown, fallback = 0.5): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  return Math.min(1, Math.max(0, value));
-}
-
-function coerceOptionalConfidence(value: unknown): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
-  return Math.min(1, Math.max(0, value));
-}
-
-function coerceOptionalString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function coerceOptionalNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function coerceStringArray(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) return undefined;
-  const strings = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
-  return strings.length > 0 ? strings : undefined;
-}
-
-function normalizeLayoutType(value: unknown): LayoutNodeType {
-  switch (value) {
-    case "page":
-    case "sidebar":
-    case "header":
-    case "toolbar":
-    case "content":
-    case "footer":
-    case "drawer":
-    case "modal":
-    case "card":
-    case "form":
-    case "form-row":
-    case "nav":
-    case "button-group":
-    case "tab-bar":
-    case "table":
-    case "table-row":
-    case "list":
-    case "list-item":
-    case "section":
-    case "overlay":
-      return value;
-    default:
-      return "content";
-  }
-}
-
-function normalizeLayoutAlignment(raw: unknown): LayoutNodeAlignment | undefined {
-  if (!raw || typeof raw !== "object") return undefined;
-  const candidate = raw as Record<string, unknown>;
-  const padding =
-    candidate.padding && typeof candidate.padding === "object"
-      ? (candidate.padding as Record<string, unknown>)
-      : null;
-
-  const direction =
-    candidate.direction === "horizontal" ||
-    candidate.direction === "vertical" ||
-    candidate.direction === "none"
-      ? candidate.direction
-      : undefined;
-
-  const distribution =
-    candidate.distribution === "start" ||
-    candidate.distribution === "center" ||
-    candidate.distribution === "end" ||
-    candidate.distribution === "space-between"
-      ? candidate.distribution
-      : undefined;
-
-  const crossAlignment =
-    candidate.crossAlignment === "start" ||
-    candidate.crossAlignment === "center" ||
-    candidate.crossAlignment === "end" ||
-    candidate.crossAlignment === "stretch"
-      ? candidate.crossAlignment
-      : undefined;
-
-  const stackingOrder =
-    candidate.stackingOrder === "normal" ||
-    candidate.stackingOrder === "reverse" ||
-    candidate.stackingOrder === "overlay"
-      ? candidate.stackingOrder
-      : undefined;
-
-  const normalizedPadding =
-    padding &&
-    [padding.top, padding.right, padding.bottom, padding.left].some((value) => coerceOptionalNumber(value) != null)
-      ? {
-          top: coerceOptionalNumber(padding.top),
-          right: coerceOptionalNumber(padding.right),
-          bottom: coerceOptionalNumber(padding.bottom),
-          left: coerceOptionalNumber(padding.left),
-        }
-      : undefined;
-
-  if (
-    direction == null &&
-    distribution == null &&
-    crossAlignment == null &&
-    coerceOptionalNumber(candidate.gap) == null &&
-    normalizedPadding == null &&
-    coerceOptionalNumber(candidate.columns) == null &&
-    stackingOrder == null
-  ) {
-    return undefined;
-  }
-
-  return {
-    direction,
-    distribution,
-    crossAlignment,
-    gap: coerceOptionalNumber(candidate.gap),
-    padding: normalizedPadding,
-    columns: coerceOptionalNumber(candidate.columns),
-    stackingOrder,
-  };
-}
-
-function normalizeLayoutNode(
-  raw: unknown,
-  path: string,
-  fallbackType: LayoutNodeType = "content"
-): LayoutNode | null {
-  if (!raw || typeof raw !== "object") return null;
-  const candidate = raw as Record<string, unknown>;
-  const boundingBox =
-    candidate.boundingBox && typeof candidate.boundingBox === "object"
-      ? (candidate.boundingBox as Record<string, unknown>)
-      : null;
-
-  if (!boundingBox) return null;
-
-  const x = coerceOptionalNumber(boundingBox.x);
-  const y = coerceOptionalNumber(boundingBox.y);
-  const width = coerceOptionalNumber(boundingBox.width);
-  const height = coerceOptionalNumber(boundingBox.height);
-
-  if ([x, y, width, height].some((value) => value == null)) return null;
-
-  const children = Array.isArray(candidate.children)
-    ? candidate.children
-        .map((child, index) => normalizeLayoutNode(child, `${path}.${index}`))
-        .filter((child): child is LayoutNode => child !== null)
-    : undefined;
-
-  const normalizedChildCount = Math.max(
-    0,
-    Math.round(
-      coerceOptionalNumber(candidate.childCount) ??
-        children?.length ??
-        0
-    )
-  );
-
-  const alignedLeftWith = coerceStringArray((candidate.siblingHints as Record<string, unknown> | undefined)?.alignedLeftWith);
-  const equalSpacingWith = coerceStringArray((candidate.siblingHints as Record<string, unknown> | undefined)?.equalSpacingWith);
-  const repeatedChildren = coerceStringArray((candidate.siblingHints as Record<string, unknown> | undefined)?.repeatedChildren);
-  const anchored =
-    (candidate.siblingHints as Record<string, unknown> | undefined)?.anchored === "left" ||
-    (candidate.siblingHints as Record<string, unknown> | undefined)?.anchored === "right" ||
-    (candidate.siblingHints as Record<string, unknown> | undefined)?.anchored === "top" ||
-    (candidate.siblingHints as Record<string, unknown> | undefined)?.anchored === "bottom" ||
-    (candidate.siblingHints as Record<string, unknown> | undefined)?.anchored === "center"
-      ? ((candidate.siblingHints as Record<string, unknown>).anchored as "left" | "right" | "top" | "bottom" | "center")
-      : undefined;
-
-  const repetitionCandidate =
-    candidate.repetition && typeof candidate.repetition === "object"
-      ? (candidate.repetition as Record<string, unknown>)
-      : null;
-
-  return {
-    id: coerceOptionalString(candidate.id) ?? path,
-    label: coerceOptionalString(candidate.label) ?? "Zone",
-    boundingBox: { x: x!, y: y!, width: width!, height: height! },
-    layoutType: normalizeLayoutType(candidate.layoutType ?? fallbackType),
-    childCount: normalizedChildCount,
-    children: children && children.length > 0 ? children : undefined,
-    layout: normalizeLayoutAlignment(candidate.layout),
-    siblingHints:
-      alignedLeftWith || equalSpacingWith || repeatedChildren || anchored || candidate.overlay === true
-        ? {
-            alignedLeftWith,
-            equalSpacingWith,
-            repeatedChildren,
-            anchored,
-            overlay: candidate.overlay === true || (candidate.siblingHints as Record<string, unknown> | undefined)?.overlay === true,
-          }
-        : undefined,
-    repetition:
-      repetitionCandidate && repetitionCandidate.isRepeated === true
-        ? {
-            isRepeated: true,
-            pattern:
-              repetitionCandidate.pattern === "row" ||
-              repetitionCandidate.pattern === "column" ||
-              repetitionCandidate.pattern === "grid" ||
-              repetitionCandidate.pattern === "tabs" ||
-              repetitionCandidate.pattern === "menu" ||
-              repetitionCandidate.pattern === "list"
-                ? repetitionCandidate.pattern
-                : undefined,
-            itemCount: coerceOptionalNumber(repetitionCandidate.itemCount),
-            canonicalChildId: coerceOptionalString(repetitionCandidate.canonicalChildId),
-            repeatedChildIds: coerceStringArray(repetitionCandidate.repeatedChildIds),
-            repeatAxis:
-              repetitionCandidate.repeatAxis === "horizontal" || repetitionCandidate.repeatAxis === "vertical"
-                ? repetitionCandidate.repeatAxis
-                : undefined,
-          }
-        : undefined,
-    zoneImage: coerceOptionalString(candidate.zoneImage),
-  };
-}
-
-function inferDirectionFromChildren(children: LayoutNode[]): "horizontal" | "vertical" | "none" {
-  if (children.length < 2) return "none";
-
-  const xSpread =
-    Math.max(...children.map((child) => child.boundingBox.x + child.boundingBox.width / 2)) -
-    Math.min(...children.map((child) => child.boundingBox.x + child.boundingBox.width / 2));
-  const ySpread =
-    Math.max(...children.map((child) => child.boundingBox.y + child.boundingBox.height / 2)) -
-    Math.min(...children.map((child) => child.boundingBox.y + child.boundingBox.height / 2));
-
-  return xSpread > ySpread ? "horizontal" : "vertical";
-}
-
-function enrichRepeatedPatterns(nodes: LayoutNode[]): LayoutNode[] {
-  return nodes.map((node) => {
-    const children = node.children ? enrichRepeatedPatterns(node.children) : undefined;
-    const nextNode: LayoutNode = { ...node, children };
-
-    if (!children || children.length < 2 || nextNode.repetition?.isRepeated) {
-      return nextNode;
-    }
-
-    const repeated = children.filter((child) => child.layoutType === children[0].layoutType);
-    const aligned =
-      repeated.length >= 2 &&
-      repeated.every((child) => {
-        const widthDelta = Math.abs(child.boundingBox.width - repeated[0].boundingBox.width);
-        const heightDelta = Math.abs(child.boundingBox.height - repeated[0].boundingBox.height);
-        return widthDelta <= 6 || heightDelta <= 6;
-      });
-
-    if (!aligned) return nextNode;
-
-    const repeatAxis =
-      nextNode.layout?.direction && nextNode.layout.direction !== "none"
-        ? nextNode.layout.direction
-        : inferDirectionFromChildren(children);
-
-    const pattern =
-      repeated[0].layoutType === "table-row"
-        ? "row"
-        : repeated[0].layoutType === "tab-bar"
-          ? "tabs"
-          : repeated[0].layoutType === "list-item"
-            ? "list"
-            : repeatAxis === "horizontal"
-              ? "row"
-              : "list";
-
-    nextNode.repetition = {
-      isRepeated: true,
-      pattern,
-      itemCount: repeated.length,
-      canonicalChildId: repeated[0].id,
-      repeatedChildIds: repeated.map((child) => child.id),
-      repeatAxis: repeatAxis === "none" ? "vertical" : repeatAxis,
-    };
-
-    return nextNode;
-  });
-}
-
-function normalizeManifest(raw: unknown): ComponentManifest {
-  if (!raw || typeof raw !== "object") return { ...DEFAULT_MANIFEST };
-
-  const candidate = raw as Record<string, unknown>;
-  const iconPresent = Boolean(candidate.iconPresent ?? candidate.iconName);
-  const normalized: ComponentManifest = {
-    componentType: coerceOptionalString(candidate.componentType) ?? DEFAULT_MANIFEST.componentType,
-    variants:
-      candidate.variants && typeof candidate.variants === "object"
-        ? Object.fromEntries(
-            Object.entries(candidate.variants as Record<string, unknown>).filter(
-              (entry): entry is [string, string] => typeof entry[1] === "string"
-            )
-          )
-        : {},
-    textContent: coerceOptionalString(candidate.textContent),
-    textContentConfidence: coerceOptionalConfidence(candidate.textContentConfidence),
-    iconPresent,
-    iconName: coerceOptionalString(candidate.iconName),
-    iconNameConfidence: coerceOptionalConfidence(candidate.iconNameConfidence),
-    iconKind:
-      candidate.iconKind === "system" ||
-      candidate.iconKind === "brand" ||
-      candidate.iconKind === "illustration" ||
-      candidate.iconKind === "unknown"
-        ? candidate.iconKind
-        : "unknown",
-    preferredIconLibrary: coerceOptionalString(candidate.preferredIconLibrary),
-    openSourceIconName: coerceOptionalString(candidate.openSourceIconName),
-    interactiveElement: Boolean(candidate.interactiveElement),
-    estimatedSpacing: coerceOptionalNumber(candidate.estimatedSpacing) ?? DEFAULT_MANIFEST.estimatedSpacing,
-    estimatedSpacingConfidence: coerceOptionalConfidence(candidate.estimatedSpacingConfidence),
-    estimatedRadius: coerceOptionalNumber(candidate.estimatedRadius),
-    estimatedRadiusConfidence: coerceOptionalConfidence(candidate.estimatedRadiusConfidence),
-    estimatedFontSize: coerceOptionalNumber(candidate.estimatedFontSize),
-    estimatedFontSizeConfidence: coerceOptionalConfidence(candidate.estimatedFontSizeConfidence),
-    fontFamilyGuess: coerceOptionalString(candidate.fontFamilyGuess),
-    fontFamilyGuessConfidence: coerceOptionalConfidence(candidate.fontFamilyGuessConfidence),
-    fontStyleGuess: coerceOptionalString(candidate.fontStyleGuess),
-    fontStyleGuessConfidence: coerceOptionalConfidence(candidate.fontStyleGuessConfidence),
-    fontWeightGuess: coerceOptionalNumber(candidate.fontWeightGuess),
-    fontWeightGuessConfidence: coerceOptionalConfidence(candidate.fontWeightGuessConfidence),
-    confidence: clampConfidence(candidate.confidence, DEFAULT_MANIFEST.confidence),
-    dsBestMatch: coerceOptionalString(candidate.dsBestMatch),
-    dsNodeId: coerceOptionalString(candidate.dsNodeId),
-  };
-
-  if (!normalized.iconPresent) {
-    normalized.iconName = undefined;
-    normalized.iconNameConfidence = undefined;
-  }
-
-  return normalized;
-}
-
-function normalizeZones(raw: unknown): LayoutZone[] | undefined {
-  if (!Array.isArray(raw)) return undefined;
-
-  const zones = raw
-    .map((zone, index) => normalizeLayoutNode(zone, `zone-${index}`))
-    .filter((zone): zone is LayoutZone => zone !== null);
-
-  return zones.length > 0 ? enrichRepeatedPatterns(zones) : undefined;
-}
-
-function normalizeVisionResult(raw: unknown): VisionResult {
-  const candidate = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};
-  const layoutTree = normalizeZones(candidate.layoutTree ?? candidate.zones);
-  return {
-    rawAnalysis:
-      typeof candidate.rawAnalysis === "string" && candidate.rawAnalysis.trim()
-        ? candidate.rawAnalysis
-        : "[Vision analysis unavailable]",
-    confidence: clampConfidence(candidate.confidence, 0.5),
-    layoutTree,
-    zones: layoutTree,
-    manifest: candidate.manifest ? normalizeManifest(candidate.manifest) : undefined,
-  };
-}
-
-/**
- * VisionClient — local heuristic image analysis utility.
- *
- * No external API key required. Returns reasonable defaults.
- * The MCP client AI provides actual vision intelligence by
- * seeing images returned in tool responses.
- */
-export class VisionClient {
-  private readonly providerName: string;
-  private readonly openaiProvider: OpenAIVisionProvider;
-  private readonly anthropicProvider: AnthropicVisionProvider;
-
-  constructor() {
-    const explicit = (process.env.VISION_PROVIDER || "").toLowerCase();
-    // Auto-detect a real vision provider when none is explicitly configured.
-    // Priority: explicit env → anthropic (if API key present) → openai (if API key present) → offline
-    if (explicit) {
-      this.providerName = explicit;
-    } else if (process.env.ANTHROPIC_API_KEY) {
-      this.providerName = "anthropic";
-    } else if (process.env.OPENAI_API_KEY) {
-      this.providerName = "openai";
-    } else {
-      this.providerName = "offline";
-    }
-    this.openaiProvider = new OpenAIVisionProvider();
-    this.anthropicProvider = new AnthropicVisionProvider();
-  }
-
-  private isOfflineProvider(): boolean {
-    return (
-      this.providerName === "offline" ||
-      this.providerName === "local" ||
-      this.providerName === "heuristic" ||
-      this.providerName === "none"
-    );
-  }
-
-  async analyze(image: string, prompt: string): Promise<VisionResult> {
-    if (this.providerName === "openai") {
-      const result = await this.openaiProvider.analyze(image, prompt);
-      return normalizeVisionResult(result);
-    }
-
-    if (this.providerName === "anthropic") {
-      const result = await this.anthropicProvider.analyze(image, prompt);
-      return normalizeVisionResult(result);
-    }
-
-    if (this.isOfflineProvider()) {
-      return {
-        rawAnalysis:
-          "[Offline heuristic analysis] Remote vision is disabled, so the cloner is using a local fallback summary.",
-        confidence: 0.25,
-      };
-    }
-
-    return {
-      rawAnalysis: `[Vision provider "${this.providerName}" is not supported]`,
-      confidence: 0,
-    };
-  }
-
-  async segment(_image: string): Promise<LayoutNode[]> {
-    const prompt = `Identify the UI layout as a nested hierarchy, not a flat zone list. Return strict JSON with:
-- rawAnalysis: short machine-readable summary string
-- confidence: overall confidence from 0 to 1
-- layoutTree: array of root layout nodes
-- each layout node must include:
-  - id: stable node id string
-  - label: descriptive name of the region
-  - boundingBox: {x, y, width, height} as percentages (0-100) of total image size
-  - layoutType: one of "page"|"sidebar"|"header"|"toolbar"|"content"|"footer"|"drawer"|"modal"|"card"|"form"|"form-row"|"nav"|"button-group"|"tab-bar"|"table"|"table-row"|"list"|"list-item"|"section"|"overlay"
-  - childCount: estimated number of direct child elements
-  - children: nested layout nodes
-  - layout: { direction, distribution, crossAlignment, gap, padding, columns, stackingOrder }
-  - siblingHints: { alignedLeftWith, equalSpacingWith, repeatedChildren, anchored, overlay }
-  - repetition: { isRepeated, pattern, itemCount, canonicalChildId, repeatedChildIds, repeatAxis } when a repeated row/list/tab/menu structure exists
-
-Prefer a single "page" root when the whole screen is one page. Include repeated row/list hints whenever items visually repeat. Only use overlays for floating drawers, modals, popovers, badges, or absolute-positioned elements.
-
-    Return ONLY valid JSON.`;
-
-    if (this.providerName === "openai") {
-      const result = await this.openaiProvider.segment(_image, prompt);
-      return normalizeVisionResult(result).layoutTree ?? [];
-    }
-
-    if (this.providerName === "anthropic") {
-      const result = await this.anthropicProvider.segment(_image, prompt);
-      return normalizeVisionResult(result).layoutTree ?? [];
-    }
-
-    if (this.isOfflineProvider()) {
-      return [
-        {
-          id: "page-root",
-          label: "Page",
-          boundingBox: { x: 0, y: 0, width: 100, height: 100 },
-          layoutType: "page",
-          childCount: 0,
-          layout: {
-            direction: "vertical",
-            distribution: "start",
-            crossAlignment: "stretch",
-            gap: 0,
-            padding: { top: 0, right: 0, bottom: 0, left: 0 },
-            stackingOrder: "normal",
-          },
-        },
-      ];
-    }
-
-    return [];
-  }
-
-  async identify(zoneImage: string): Promise<ComponentManifest> {
-    const prompt = `Analyze this UI region and identify the component. Return JSON with:
-- componentType: specific UI component name (e.g. "PrimaryButton", "TextInput", "NavigationBar")
-- variants: object of detected variants {size, state, theme, type}
-- textContent: visible text content (null if none)
-- iconPresent: boolean
-- iconName: best guess for the icon or logo name (null if none)
-- iconKind: "system" | "brand" | "illustration" | "unknown"
-- preferredIconLibrary: best open-source icon family for this region, prefer "material-symbols" for common UI icons and "simple-icons" for brands
-- openSourceIconName: exact open-source icon slug if recognizable (examples: "menu", "search", "close", "shopping_cart")
-- interactiveElement: boolean (is this clickable/focusable?)
-- estimatedSpacing: measured padding/gap in pixels, prefer exact visual estimate over assumptions
-- estimatedRadius: border radius in pixels if visible
-- estimatedFontSize: visible text size in pixels if text is present
-- fontFamilyGuess: closest visible font family name if text is present
-- fontStyleGuess: closest visible font style name if text is present
-- fontWeightGuess: closest visible font weight number if text is present
-- confidence: 0-1 how confident you are in this identification
-
-Return ONLY valid JSON.`;
-
-    if (this.providerName === "openai") {
-      const result = await this.openaiProvider.identify(zoneImage, prompt);
-      return normalizeVisionResult(result).manifest ?? { ...DEFAULT_MANIFEST };
-    }
-
-    if (this.providerName === "anthropic") {
-      const result = await this.anthropicProvider.identify(zoneImage, prompt);
-      return normalizeVisionResult(result).manifest ?? { ...DEFAULT_MANIFEST };
-    }
-
-    if (this.isOfflineProvider()) {
-      return {
-        ...DEFAULT_MANIFEST,
-        componentType: "ScreenshotRegion",
-        interactiveElement: false,
-        estimatedSpacing: 0,
-        confidence: 0.2,
-      };
-    }
-
-    return { ...DEFAULT_MANIFEST };
-  }
-
-  async describeComponent(image: string): Promise<string> {
-    const prompt = `Describe this UI component in one concise sentence focusing on its purpose, visual style, and key properties. Be specific about size, color, state, and interactive behavior.`;
-    const result = await this.analyze(image, prompt);
-    return result.rawAnalysis;
-  }
-
-  async auditVisualQuality(
-    image: string,
-    areas: string[]
-  ): Promise<Record<string, unknown>> {
-    const prompt = `Perform a professional UX quality audit of this UI screenshot. Analyze: ${areas.join(", ")}.
-
-Return JSON with:
-{
-  "hierarchyScore": 0-100,
-  "cognitiveLoadRating": "low"|"medium"|"high",
-  "brandAlignmentNotes": "...",
-  "consistencyIssues": ["..."],
-  "overallScore": 0-100,
-  "topIssues": [{"severity":"error"|"warning"|"suggestion","description":"...","area":"..."}],
-  "estimatedFixTimeMinutes": N
-}
-
-Return ONLY valid JSON.`;
-
-    const result = await this.analyze(image, prompt);
-    try {
-      const jsonMatch = result.rawAnalysis.match(/```json\n?([\s\S]*?)\n?```/);
-      if (jsonMatch) return JSON.parse(jsonMatch[1]);
-      return JSON.parse(result.rawAnalysis);
-    } catch {
-      return { rawAnalysis: result.rawAnalysis };
-    }
-  }
-
-  async interpretSketch(
-    _image: string,
-    _productContext: string
-  ): Promise<LayoutZone[]> {
-    return [
-      { id: "sketch-header", label: "Top Section", boundingBox: { x: 0, y: 0, width: 100, height: 20 }, layoutType: "header", childCount: 2 },
-      { id: "sketch-content", label: "Content Area", boundingBox: { x: 0, y: 20, width: 100, height: 60 }, layoutType: "content", childCount: 4 },
-      { id: "sketch-footer", label: "Action Area", boundingBox: { x: 0, y: 80, width: 100, height: 20 }, layoutType: "footer", childCount: 2 },
-    ];
-  }
-
-  async extractDesignLanguage(
-    _references: string[],
-    _extractTypes: string[]
-  ): Promise<Record<string, unknown>> {
-    return {
-      layout: { gridStructure: "12-column", zoneProportions: "balanced", hierarchy: "standard" },
-      spacing: { density: "comfortable", paddingPattern: "16px", dominantGap: 16 },
-      colorPalette: [
-        { role: "primary", hex: "#2563EB", frequency: "dominant" },
-        { role: "surface", hex: "#FFFFFF", frequency: "dominant" },
-        { role: "text", hex: "#1E293B", frequency: "dominant" },
-      ],
-      typography: { scalePattern: "modular", dominantWeights: [400, 600], hierarchyLevels: 3 },
-    };
-  }
-}