inkhouse 0.1.0-beta.0

package/src/pack-provider.ts

@@ -0,0 +1,148 @@
+import { debug } from './colors';
+import { waitForUIReady } from './dev-server';
+import { normalizePack } from './packs';
+import type { Pack } from './packs';
+import type { ProjectConfig } from './config';
+
+type PackFetchResult = {
+  requestId: string;
+  data: any | null;
+  source?: string;
+  error?: string;
+};
+
+type PackFetchConfig = Pick<ProjectConfig, 'tokenPath' | 'tokenSourceMode' | 'cssTokenPath'>;
+
+const PACK_PORTS = [4000, 3000, 5173];
+const PACK_PATHS = ['api/figma/scan-components'];
+const SUPPORTED_SCHEMA_VERSION = 1;
+const SUPPORTED_COMPONENT_DEFS_MAJOR = 1;
+
+let pendingFetches: Record<string, (result: PackFetchResult) => void> = {};
+let fetchCounter = 0;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getComponentDefsPayload(raw: unknown): Record<string, unknown> | null {
+  if (!isPlainObject(raw)) return null;
+
+  // Direct component-definitions payload
+  if (Array.isArray((raw as any).components)) {
+    return raw;
+  }
+
+  // Pack envelope payload: { components: { ...componentDefs } }
+  const nested = (raw as any).components;
+  if (isPlainObject(nested) && Array.isArray((nested as any).components)) {
+    return nested;
+  }
+  return null;
+}
+
+function parseMajor(version: unknown): number | null {
+  if (typeof version !== 'string') return null;
+  const match = version.trim().match(/^(\d+)(?:\.\d+){0,2}$/);
+  if (!match) return null;
+  const major = parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+function validateComponentDefsContract(raw: unknown): { ok: true } | { ok: false; error: string } {
+  const defs = getComponentDefsPayload(raw);
+  if (!defs) return { ok: false, error: 'invalid-pack' };
+
+  const schemaVersion = (defs as any).schemaVersion;
+  if (typeof schemaVersion === 'number') {
+    if (schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
+      return { ok: false, error: 'incompatible-schema-version' };
+    }
+    return { ok: true };
+  }
+
+  // Backward compatibility with older payloads that only had `version`.
+  const major = parseMajor((defs as any).version);
+  if (major != null && major !== SUPPORTED_COMPONENT_DEFS_MAJOR) {
+    return { ok: false, error: 'incompatible-pack-version' };
+  }
+  return { ok: true };
+}
+
+function buildPackCandidates(config?: PackFetchConfig): string[] {
+  const urls: string[] = [];
+  for (let i = 0; i < PACK_PORTS.length; i++) {
+    const port = PACK_PORTS[i];
+    for (let j = 0; j < PACK_PATHS.length; j++) {
+      const path = PACK_PATHS[j];
+      if (!path) continue;
+      const baseUrl = 'http://localhost:' + port + '/' + path;
+      const query: string[] = [];
+      const requestedMode = config?.tokenSourceMode;
+      if (requestedMode === 'auto' || requestedMode === 'css' || requestedMode === 'dtcg') {
+        query.push('tokenSourceMode=' + encodeURIComponent(requestedMode));
+      }
+      const cssTokenPath = (config?.cssTokenPath || '').trim();
+      if (cssTokenPath) {
+        query.push('cssTokenPath=' + encodeURIComponent(cssTokenPath));
+      }
+      const dtcgTokenPath = (config?.tokenPath || '').trim();
+      if (dtcgTokenPath) {
+        query.push('dtcgTokenPath=' + encodeURIComponent(dtcgTokenPath));
+      }
+      const urlString = query.length ? (baseUrl + '?' + query.join('&')) : baseUrl;
+      urls.push(urlString);
+    }
+  }
+  return urls;
+}
+
+export async function fetchPackFromUI(config?: PackFetchConfig): Promise<PackFetchResult> {
+  await waitForUIReady();
+
+  return new Promise<PackFetchResult>(function (resolve) {
+    const requestId = 'pack-' + ++fetchCounter;
+    pendingFetches[requestId] = resolve;
+    figma.ui.postMessage({
+      type: 'fetch-pack',
+      requestId: requestId,
+      candidates: buildPackCandidates(config),
+    });
+    setTimeout(function () {
+      if (pendingFetches[requestId]) {
+        delete pendingFetches[requestId];
+        resolve({ requestId: requestId, data: null, error: 'timeout' });
+      }
+    }, 30000);
+  });
+}
+
+export function handlePackResult(msg: PackFetchResult): void {
+  const cb = pendingFetches[msg.requestId];
+  if (cb) {
+    delete pendingFetches[msg.requestId];
+    cb(msg);
+  }
+}
+
+export async function refreshPack(config?: PackFetchConfig): Promise<{ success: boolean; pack: Pack | null; source?: string; error?: string }> {
+  const result = await fetchPackFromUI(config);
+  if (!result || !result.data) {
+    debug('Pack fetch failed', { error: result ? result.error : 'no-result' });
+    return { success: false, pack: null, error: result ? result.error : 'no-result' };
+  }
+
+  const contract = validateComponentDefsContract(result.data);
+  if (!contract.ok) {
+    debug('Pack contract validation failed', { error: contract.error });
+    return { success: false, pack: null, error: contract.error };
+  }
+
+  const pack = normalizePack(result.data, result.source || 'pack');
+  if (!pack) {
+    debug('Pack data invalid');
+    return { success: false, pack: null, error: 'invalid-pack' };
+  }
+
+  return { success: true, pack: pack, source: result.source };
+}

package/src/packs.ts

@@ -0,0 +1,126 @@
+import { COMPONENT_DEFS } from './tokens';
+import type { ComponentDefs } from './tokens';
+import { createEmptyScannedTokenMap, type ScannedTokenMap } from './token-source';
+
+export type StoryDefinition = {
+  id: string;
+  name: string;
+  layoutClasses?: string[] | string;
+  jsxTree?: any;
+  instances?: any[];
+  tags?: string[];
+};
+
+export type Pack = {
+  id: string;
+  name: string;
+  version?: string;
+  components: ComponentDefs;
+  tokens?: ScannedTokenMap;
+  stories?: StoryDefinition[];
+  tags?: string[];
+};
+
+let ACTIVE_PACK: Pack | null = null;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeComponentDefs(raw: any): ComponentDefs {
+  const out: ComponentDefs = {
+    schemaVersion: undefined,
+    version: undefined,
+    generatedAt: undefined,
+    components: [],
+    spacingScale: {},
+    colorTokens: [],
+    paletteTokens: {},
+    iconRegistry: {},
+    styleMap: {},
+  };
+  if (!raw || !isPlainObject(raw)) return out;
+  if (typeof raw.schemaVersion === 'number' && Number.isFinite(raw.schemaVersion)) {
+    out.schemaVersion = raw.schemaVersion;
+  }
+  if (typeof raw.version === 'string') out.version = raw.version;
+  if (typeof raw.generatedAt === 'string') out.generatedAt = raw.generatedAt;
+  if (Array.isArray(raw.components)) out.components = raw.components;
+  if (isPlainObject(raw.spacingScale)) out.spacingScale = raw.spacingScale as Record<string, any>;
+  if (Array.isArray(raw.colorTokens)) out.colorTokens = raw.colorTokens;
+  if (isPlainObject(raw.paletteTokens)) out.paletteTokens = raw.paletteTokens as Record<string, string>;
+  if (isPlainObject(raw.iconRegistry)) out.iconRegistry = raw.iconRegistry as Record<string, any>;
+  if (isPlainObject(raw.styleMap)) out.styleMap = raw.styleMap as Record<string, any>;
+  return out;
+}
+
+function normalizeTokenMap(raw: any): ScannedTokenMap | undefined {
+  if (!raw || !isPlainObject(raw)) return undefined;
+  const mode = raw.mode === 'css' || raw.mode === 'dtcg' || raw.mode === 'embedded'
+    ? raw.mode
+    : 'embedded';
+  const requestedMode = raw.requestedMode === 'css' || raw.requestedMode === 'dtcg' || raw.requestedMode === 'auto'
+    ? raw.requestedMode
+    : undefined;
+  const out = createEmptyScannedTokenMap(
+    mode,
+    typeof raw.source === 'string' && raw.source ? raw.source : 'embedded:tokens.ts',
+    requestedMode
+  );
+  if (isPlainObject(raw.colors)) out.colors = raw.colors as Record<string, string>;
+  if (isPlainObject(raw.radius)) out.radius = raw.radius as Record<string, number>;
+  if (isPlainObject(raw.fonts)) out.fonts = raw.fonts as Record<string, string>;
+  if (isPlainObject(raw.spacing)) out.spacing = raw.spacing as Record<string, number>;
+  if (isPlainObject(raw.fontSize)) out.fontSize = raw.fontSize as Record<string, number>;
+  if (isPlainObject(raw.shadows)) out.shadows = raw.shadows as Record<string, string>;
+  if (isPlainObject(raw.themes)) out.themes = raw.themes as Record<string, any>;
+  return out;
+}
+
+export function normalizePack(raw: any, fallbackId: string): Pack | null {
+  if (!raw) return null;
+
+  let componentDefs: any = null;
+  if (raw.components && Array.isArray(raw.components)) {
+    componentDefs = raw;
+  } else if (raw.components && isPlainObject(raw.components) && Array.isArray(raw.components.components)) {
+    componentDefs = raw.components;
+  }
+
+  if (!componentDefs) return null;
+
+  const packId = typeof raw.id === 'string' && raw.id ? raw.id : fallbackId;
+  const packName = typeof raw.name === 'string' && raw.name ? raw.name : packId;
+
+  return {
+    id: packId,
+    name: packName,
+    version: typeof raw.version === 'string' ? raw.version : undefined,
+    components: normalizeComponentDefs(componentDefs),
+    tokens: normalizeTokenMap((raw as any).tokens),
+    stories: Array.isArray(raw.stories) ? raw.stories : undefined,
+    tags: Array.isArray(raw.tags) ? raw.tags : undefined,
+  };
+}
+
+export function applyPack(pack: Pack): void {
+  ACTIVE_PACK = pack;
+  const defs = normalizeComponentDefs(pack.components);
+  COMPONENT_DEFS.components = defs.components;
+  COMPONENT_DEFS.schemaVersion = defs.schemaVersion;
+  COMPONENT_DEFS.version = defs.version;
+  COMPONENT_DEFS.generatedAt = defs.generatedAt;
+  COMPONENT_DEFS.spacingScale = defs.spacingScale;
+  COMPONENT_DEFS.colorTokens = defs.colorTokens;
+  COMPONENT_DEFS.paletteTokens = defs.paletteTokens;
+  COMPONENT_DEFS.iconRegistry = defs.iconRegistry;
+  COMPONENT_DEFS.styleMap = defs.styleMap;
+}
+
+export function getActivePack(): Pack | null {
+  return ACTIVE_PACK;
+}
+
+export function getActiveStories(): StoryDefinition[] {
+  return ACTIVE_PACK && ACTIVE_PACK.stories ? ACTIVE_PACK.stories : [];
+}

package/src/radial-gradient.ts

@@ -0,0 +1,84 @@
+import type { Transform2x3 } from './transform-math';
+
+export type RadialAnchor = {
+  x: number;
+  y: number;
+};
+
+export function parseRadialAnchorFromUtility(utility: string): RadialAnchor | null {
+  const match = utility.match(/^bg-radial-\[at_(.+)\]$/);
+  if (!match) return null;
+  const token = match[1].trim();
+  if (!token) return null;
+
+  const keywordMap: Record<string, RadialAnchor> = {
+    center: { x: 0.5, y: 0.5 },
+    top: { x: 0.5, y: 0 },
+    bottom: { x: 0.5, y: 1 },
+    left: { x: 0, y: 0.5 },
+    right: { x: 1, y: 0.5 },
+    top_left: { x: 0, y: 0 },
+    top_right: { x: 1, y: 0 },
+    bottom_left: { x: 0, y: 1 },
+    bottom_right: { x: 1, y: 1 },
+  };
+
+  const keyword = keywordMap[token];
+  if (keyword) return keyword;
+
+  const parts = token.split('_');
+  if (parts.length !== 2) return null;
+  const x = parsePercent(parts[0]);
+  const y = parsePercent(parts[1]);
+  if (x == null || y == null) return null;
+  return { x, y };
+}
+
+function parsePercent(value: string): number | null {
+  const match = value.match(/^(-?\d+(?:\.\d+)?)%$/);
+  if (!match) return null;
+  const pct = parseFloat(match[1]);
+  if (!Number.isFinite(pct)) return null;
+  return pct / 100;
+}
+
+export function radialGradientTransformFromAnchor(
+  anchor: RadialAnchor = { x: 0.5, y: 0.5 },
+): Transform2x3 {
+  // CSS `radial-gradient(...)` defaults to `ellipse farthest-corner at center`.
+  // In normalized box space, that is a circle whose radius is the max distance
+  // from anchor to any corner.
+  const corners: Array<{ x: number; y: number }> = [
+    { x: 0, y: 0 },
+    { x: 1, y: 0 },
+    { x: 0, y: 1 },
+    { x: 1, y: 1 },
+  ];
+  let farthestDistance = 0;
+  for (const corner of corners) {
+    const dx = corner.x - anchor.x;
+    const dy = corner.y - anchor.y;
+    const dist = Math.sqrt((dx * dx) + (dy * dy));
+    if (dist > farthestDistance) farthestDistance = dist;
+  }
+  if (!Number.isFinite(farthestDistance) || farthestDistance <= 0) {
+    farthestDistance = Math.SQRT2 / 2;
+  }
+
+  // Figma `gradientTransform` is inverse-mapped for sampling, but radial paints
+  // use a half-unit basis for the default radius in local gradient space.
+  // For a target center (cx, cy) and radius r in normalized object coordinates:
+  //   u = (x - cx) / (2r)
+  //   v = (y - cy) / (2r)
+  // represented as:
+  //   [u]   [1/(2r)   0      0.5 - cx/(2r)] [x]
+  //   [v] = [0      1/(2r)   0.5 - cy/(2r)] [y]
+  //                               [1]
+  const scale = 0.5 / farthestDistance;
+  const tx = 0.5 - (scale * anchor.x);
+  const ty = 0.5 - (scale * anchor.y);
+  return [
+    [scale, 0, tx],
+    [0, scale, ty],
+  ];
+}

package/src/render-context.ts

@@ -0,0 +1,138 @@
+import type { RGB } from './colors';
+import { splitClassName } from './node-ir';
+import { getBaseClass } from './width-solver';
+
+export type RenderContext = {
+  maxWidth?: number;
+  textAlign?: 'LEFT' | 'CENTER' | 'RIGHT';
+  textFontSize?: number;
+  textBold?: boolean;
+  /** Figma font style string (e.g. 'Medium', 'SemiBold', 'Bold') — overrides textBold when set */
+  textFontStyle?: string;
+  textLineHeight?: number;
+  parentLayout?: 'HORIZONTAL' | 'VERTICAL';
+  textColor?: string | RGB | null;
+  textColorToken?: string;
+  parentCompoundDef?: any;
+  accordionOpenValue?: string | null;
+  accordionItemIndex?: number;
+  accordionItemValue?: string | null;
+  accordionItemIsOpen?: boolean;
+  /** Pre-fetched images: src path → figma imageHash */
+  imageMap?: Map<string, string>;
+  /** Text truncation: true when `truncate` or `line-clamp-N` is active */
+  textTruncate?: boolean;
+  /** Maximum lines before truncation (1 for `truncate`, N for `line-clamp-N`) */
+  textMaxLines?: number;
+};
+
+export const TEXT_LINE_DEFAULT_WIDTHS = ['full', 'twoThirds', 'half', 'third'];
+export const TEXT_LINE_WIDTH_CLASSES: Record<string, string> = {
+  full: 'w-full',
+  half: 'w-1/2',
+  third: 'w-1/3',
+  twoThirds: 'w-2/3',
+};
+
+export function parseTextLineCount(value: unknown): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return Math.max(1, Math.floor(value));
+  if (typeof value === 'string') {
+    const parsed = parseInt(value, 10);
+    if (Number.isFinite(parsed)) return Math.max(1, parsed);
+  }
+  return 3;
+}
+
+export function parseWidthTokenList(value: unknown): string[] {
+  const sanitize = (raw: unknown[]): string[] => {
+    const out: string[] = [];
+    for (const entry of raw) {
+      if (typeof entry !== 'string') continue;
+      const key = entry.trim();
+      if (TEXT_LINE_WIDTH_CLASSES[key]) out.push(key);
+    }
+    return out.length > 0 ? out : TEXT_LINE_DEFAULT_WIDTHS.slice();
+  };
+
+  if (Array.isArray(value)) return sanitize(value);
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) return sanitize(parsed);
+      } catch (_err) {
+        // ignore parse errors
+      }
+    }
+    const split = trimmed.split(',').map(part => part.trim()).filter(Boolean);
+    if (split.length > 0) return sanitize(split);
+  }
+  return TEXT_LINE_DEFAULT_WIDTHS.slice();
+}
+
+export function detectWidthTokenList(value: unknown): string[] {
+  const sanitize = (raw: unknown[]): string[] => {
+    const out: string[] = [];
+    for (const entry of raw) {
+      if (typeof entry !== 'string') continue;
+      const key = entry.trim();
+      if (TEXT_LINE_WIDTH_CLASSES[key]) out.push(key);
+    }
+    return out;
+  };
+
+  if (Array.isArray(value)) return sanitize(value);
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) return sanitize(parsed);
+      } catch (_err) {
+        // ignore parse errors
+      }
+    }
+    const split = trimmed.split(',').map(part => part.trim()).filter(Boolean);
+    if (split.length > 0) return sanitize(split);
+  }
+  return [];
+}
+
+export function hasWidthHintInClasses(classes: string[]): boolean {
+  for (const cls of classes) {
+    const base = getBaseClass(cls) || cls.split(':').pop() || '';
+    if (base === 'w-full') return true;
+    if (/^w-\d+\/\d+$/.test(base)) return true;
+  }
+  return false;
+}
+
+export function propsContainWidthHint(props: Record<string, any> | undefined): boolean {
+  if (!props) return false;
+  if (props.className && hasWidthHintInClasses(splitClassName(props.className))) return true;
+  for (const key in props) {
+    const value = props[key];
+    if (typeof value === 'string') {
+      if (value.indexOf('w-') !== -1 && hasWidthHintInClasses(splitClassName(value))) return true;
+      if (detectWidthTokenList(value).length > 0) return true;
+    } else if (Array.isArray(value)) {
+      if (detectWidthTokenList(value).length > 0) return true;
+    }
+  }
+  return false;
+}
+
+export function hasExplicitHeight(classes: string[] | undefined): boolean {
+  if (!classes) return false;
+  for (const cls of classes) {
+    const base = getBaseClass(cls);
+    if (!base) continue;
+    if (base.startsWith('h-')) return true;
+    if (base.startsWith('min-h-')) return true;
+    if (base.startsWith('max-h-')) return true;
+    if (base.startsWith('size-')) return true;
+    if (base.startsWith('aspect-')) return true;
+  }
+  return false;
+}

package/src/responsive-analyzer.ts

@@ -0,0 +1,139 @@
+import { parseUtilityClass } from './utility-resolver';
+
+export type BreakpointInfo = {
+  name: string;
+  minWidth: number;
+  classes: string[];
+  changes?: PropertyChange[];
+};
+
+export type PropertyChange = {
+  property: string;
+  fromValue: string;
+  toValue: string;
+};
+
+const BREAKPOINTS: Record<string, number> = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  '2xl': 1536,
+};
+
+const BREAKPOINT_ORDER = ['sm', 'md', 'lg', 'xl', '2xl'];
+
+function isResponsiveVariant(variant: string): boolean {
+  return BREAKPOINTS[variant] != null;
+}
+
+function normalizeUtility(atom: ReturnType<typeof parseUtilityClass>): string | null {
+  if (!atom.utility) return null;
+  return atom.important ? '!' + atom.utility : atom.utility;
+}
+
+function splitResponsiveClass(cls: string): { bucket: string; utility: string | null } | null {
+  const atom = parseUtilityClass(cls);
+  const utility = normalizeUtility(atom);
+  if (!utility) return null;
+
+  const responsiveVariants: string[] = [];
+  const remainingVariants: string[] = [];
+  for (let i = 0; i < atom.variants.length; i++) {
+    const v = atom.variants[i];
+    if (isResponsiveVariant(v)) {
+      responsiveVariants.push(v);
+    } else {
+      remainingVariants.push(v);
+    }
+  }
+
+  if (responsiveVariants.length === 0) {
+    if (remainingVariants.length > 0) return null;
+    return { bucket: 'base', utility: utility };
+  }
+
+  if (remainingVariants.length > 0) return null;
+  const bucket = responsiveVariants[responsiveVariants.length - 1];
+  return { bucket: bucket, utility: utility };
+}
+
+function buildResponsiveBuckets(classes: string[]): Record<string, string[]> {
+  const buckets: Record<string, string[]> = { base: [] };
+  for (let i = 0; i < BREAKPOINT_ORDER.length; i++) {
+    buckets[BREAKPOINT_ORDER[i]] = [];
+  }
+
+  for (let i = 0; i < classes.length; i++) {
+    const entry = splitResponsiveClass(classes[i]);
+    if (!entry || !entry.utility) continue;
+    const bucketList = buckets[entry.bucket];
+    if (bucketList) {
+      bucketList.push(entry.utility);
+    } else {
+      buckets[entry.bucket] = [entry.utility];
+    }
+  }
+
+  return buckets;
+}
+
+export function extractBreakpointsFromClasses(classes: string[]): BreakpointInfo[] {
+  const buckets = buildResponsiveBuckets(classes);
+  const hasResponsive = BREAKPOINT_ORDER.some(bp => (buckets[bp] && buckets[bp].length > 0));
+  const hasBase = buckets.base && buckets.base.length > 0;
+  if (!hasBase && !hasResponsive) return [];
+
+  const result: BreakpointInfo[] = [];
+  result.push({ name: 'base', minWidth: 0, classes: buckets.base || [] });
+
+  for (let i = 0; i < BREAKPOINT_ORDER.length; i++) {
+    const bp = BREAKPOINT_ORDER[i];
+    const list = buckets[bp];
+    if (!list || list.length === 0) continue;
+    result.push({ name: bp, minWidth: BREAKPOINTS[bp], classes: list });
+  }
+
+  return result;
+}
+
+export function getClassesForBreakpoint(classes: string[], breakpoint: string): string[] {
+  const buckets = buildResponsiveBuckets(classes);
+  const output: string[] = [];
+
+  if (buckets.base && buckets.base.length > 0) {
+    for (let i = 0; i < buckets.base.length; i++) output.push(buckets.base[i]);
+  }
+
+  const targetIndex = BREAKPOINT_ORDER.indexOf(breakpoint);
+  if (breakpoint === 'base' || targetIndex === -1) {
+    return output;
+  }
+
+  for (let i = 0; i <= targetIndex; i++) {
+    const bp = BREAKPOINT_ORDER[i];
+    const list = buckets[bp];
+    if (!list || list.length === 0) continue;
+    for (let j = 0; j < list.length; j++) output.push(list[j]);
+  }
+
+  return output;
+}
+
+export function analyzeBreakpointChanges(_classes: string[]): PropertyChange[] {
+  return [];
+}
+
+export function hasSignificantResponsiveChanges(classes: string[]): boolean {
+  const buckets = buildResponsiveBuckets(classes);
+  for (let i = 0; i < BREAKPOINT_ORDER.length; i++) {
+    const bp = BREAKPOINT_ORDER[i];
+    if (buckets[bp] && buckets[bp].length > 0) return true;
+  }
+  return false;
+}
+
+export function getBreakpointLabel(name: string, minWidth: number): string {
+  if (name === 'base') return 'Base';
+  return name + ' ≥' + minWidth;
+}