@design.estate/wcctools 6.0.0 → 6.2.0

package/ts/standards/rules/shared.ts

@@ -0,0 +1,127 @@
+import * as plugins from '../../plugins.js';
+import * as ast from '../helpers.ast.js';
+import { baseOf, dirOf, specifierFor } from '../helpers.paths.js';
+import type { IStandardElement, IStandardProperty, StandardProject } from '../classes.standardproject.js';
+import type { IFixBuilder } from '../rule.js';
+
+const ts = plugins.typescript;
+
+export const elementsDir = 'ts_web/elements';
+
+/** `ts_web/elements/00group-<area>` or `ts_web/elements` itself. */
+export const isElementParentDir = (dirArg: string): boolean =>
+  dirArg === elementsDir || /^ts_web\/elements\/00group-[^/]+$/.test(dirArg);
+
+/** Names the HTML specification reserves; `customElements.define` rejects them. */
+const reservedElementNames = ['annotation-xml', 'color-profile', 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format', 'font-face-name', 'missing-glyph'];
+
+/**
+ * A valid custom element name in the ASCII subset the standard allows: a lowercase letter first,
+ * then lowercase letters, digits, `-`, `.` and `_`, at least one `-`, and not a reserved name. Such
+ * a tag is also a safe file and folder name, so only these tags feed fixes that derive paths or code.
+ */
+export const isCustomElementName = (tagArg: string): boolean =>
+  /^[a-z][a-z0-9._-]*$/.test(tagArg) && tagArg.includes('-') && !reservedElementNames.includes(tagArg);
+
+/** True when an element's entry file sits in its own element folder `…/<tag>/`. */
+export const isInElementFolder = (elementArg: IStandardElement): boolean => {
+  const folder = dirOf(elementArg.file);
+  return !!elementArg.tag && baseOf(folder) === elementArg.tag && isElementParentDir(dirOf(folder));
+};
+
+/** The `<area>` of `ts_web/elements/00group-<area>/…`, or null. */
+export const groupAreaOf = (fileArg: string): string | null => /^ts_web\/elements\/00group-([^/]+)\//.exec(fileArg)?.[1] ?? null;
+
+/** Elements outside demo files: the catalog's own elements. */
+export const catalogElements = (projectArg: StandardProject): IStandardElement[] =>
+  projectArg.elements.filter((elementArg) => !elementArg.inDemoFile);
+
+/** Public `@property` members outside demo files. */
+export const publicProperties = (projectArg: StandardProject): IStandardProperty[] =>
+  projectArg.properties.filter((propertyArg) => propertyArg.decorator === 'property' && propertyArg.isPublic && !propertyArg.inDemoFile);
+
+export const elementKey = (elementArg: IStandardElement): string => `${elementArg.file}#${elementArg.className ?? elementArg.tag ?? '?'}`;
+
+export const propertyKey = (propertyArg: IStandardProperty): string => `${propertyArg.file}#${propertyArg.name}`;
+
+/** The type annotation of a property member without `undefined` and `null` union members. */
+export const coreTypeOf = (propertyArg: IStandardProperty): ast.TTypeNode | null => {
+  const member = propertyArg.member;
+  const typeNode = ts.isPropertyDeclaration(member) ? member.type : undefined;
+  if (!typeNode) {
+    return null;
+  }
+  if (ts.isUnionTypeNode(typeNode)) {
+    const members = typeNode.types.filter((typeArg) =>
+      typeArg.kind !== ts.SyntaxKind.UndefinedKeyword
+      && !(ts.isLiteralTypeNode(typeArg) && typeArg.literal.kind === ts.SyntaxKind.NullKeyword));
+    if (members.length === 1) {
+      return members[0];
+    }
+    return typeNode;
+  }
+  return typeNode;
+};
+
+export const isArrayTypeNode = (typeArg: ast.TTypeNode): boolean => {
+  if (ts.isArrayTypeNode(typeArg)) {
+    return true;
+  }
+  if (ts.isTypeOperatorNode(typeArg) && typeArg.operator === ts.SyntaxKind.ReadonlyKeyword) {
+    return ts.isArrayTypeNode(typeArg.type);
+  }
+  return ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && ['Array', 'ReadonlyArray'].includes(typeArg.typeName.text);
+};
+
+/** The position at the start of the line after the last `export … from` statement, or at the end of the file. */
+export const exportInsertionPoint = (sourceFileArg: ast.TSourceFile): { position: number; prefix: string } => {
+  let lastEnd = -1;
+  for (const statement of sourceFileArg.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      lastEnd = statement.end;
+    }
+  }
+  const text = sourceFileArg.text;
+  if (lastEnd === -1) {
+    return { position: text.length, prefix: text.length > 0 && !text.endsWith('\n') ? '\n' : '' };
+  }
+  const newline = text.indexOf('\n', lastEnd);
+  return newline === -1 ? { position: text.length, prefix: '\n' } : { position: newline + 1, prefix: '' };
+};
+
+/** Adds `export * from '<target>';` to a barrel. */
+export const addReexport = (builderArg: IFixBuilder, projectArg: StandardProject, barrelArg: string, targetArg: string): void => {
+  const point = exportInsertionPoint(projectArg.sourceFile(barrelArg));
+  builderArg.edit(barrelArg, point.position, point.position, `${point.prefix}export * from '${specifierFor(barrelArg, targetArg, 'js')}';\n`);
+};
+
+/** Removes a whole statement including its line break; from the line start when only indentation precedes it. */
+export const removeStatement = (builderArg: IFixBuilder, fileArg: string, statementArg: ast.TNode): void => {
+  const text = statementArg.getSourceFile().text;
+  let start = statementArg.getStart();
+  const lineStart = text.lastIndexOf('\n', start - 1) + 1;
+  if (/^[ \t]*$/.test(text.slice(lineStart, start))) {
+    start = lineStart;
+  }
+  let end = statementArg.end;
+  const rest = /^[ \t]*\r?\n/.exec(text.slice(end));
+  if (rest) {
+    end += rest[0].length;
+  }
+  builderArg.edit(fileArg, start, end, '');
+};
+
+/** The identifier a `static demo` value refers to at its root, e.g. `demoFunc` or `demos` in `demos.main`. */
+export const rootIdentifier = (expressionArg: ast.TExpression): string | null => {
+  let current: ast.TExpression = expressionArg;
+  while (ts.isPropertyAccessExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isIdentifier(current) ? current.text : null;
+};
+
+/** The start of the line following the line a position is on. */
+export const nextLineStart = (textArg: string, positionArg: number): number => {
+  const newline = textArg.indexOf('\n', positionArg);
+  return newline === -1 ? textArg.length : newline + 1;
+};

package/ts/standards/rules/style.bdtheme.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../../plugins.js';
+import * as ast from '../helpers.ast.js';
+import type { IRuleFinding, IStandardRule } from '../rule.js';
+
+const ts = plugins.typescript;
+
+/** The one module that may call `bdTheme()`: the token bridge. */
+export const bdThemeBridge = 'ts_web/elements/00theme.ts';
+
+/** dees: no new `cssManager.bdTheme()` call outside `ts_web/elements/00theme.ts`. A ratchet: baselines only. */
+export const styleBdThemeRule: IStandardRule = {
+  id: 'style/bdtheme',
+  severity: { dees: 'error' },
+  fixMode: 'none',
+  detect: ({ project }) => {
+    const findings: IRuleFinding[] = [];
+    for (const file of project.webFiles) {
+      if (file === bdThemeBridge) {
+        continue;
+      }
+      const visit = (nodeArg: ast.TNode): void => {
+        if (ts.isCallExpression(nodeArg) && ast.calleeName(nodeArg.expression) === 'bdTheme') {
+          findings.push({ file, position: nodeArg.getStart(), key: file, message: 'bdTheme() call; use --dees-* tokens' });
+        }
+        ts.forEachChild(nodeArg, visit);
+      };
+      visit(project.sourceFile(file));
+    }
+    return findings;
+  },
+};

package/ts_interfaces/bridge.ts

@@ -0,0 +1,95 @@
+import type { IWccCatalogManifest } from './catalog.js';
+
+/**
+ * The bridge between the shell and the preview document. The preview runtime installs it as
+ * `window.wccPreview` in the preview document; the shell reaches it through the same-origin
+ * iframe. Every argument and result is plain, structured-cloneable data: values never carry
+ * objects of the other document's realm.
+ */
+
+export type TWccTheme = 'dark' | 'bright';
+
+/** One demo (or page) of the catalog. */
+export interface IWccSelection {
+  sectionName: string;
+  itemName: string;
+  /** 0-based; always 0 for a page. */
+  demoIndex: number;
+}
+
+/** What the preview shows instead of a demo. */
+export interface IWccEmptyState {
+  title: string;
+  detail: string;
+}
+
+export type TWccEmptyReason =
+  | 'nothing-selected'
+  | 'no-demo'
+  | 'ignored'
+  | 'missing'
+  | 'no-such-demo'
+  | 'failed';
+
+export type TWccRenderOutcome =
+  | { kind: 'rendered'; type: 'element' | 'page' }
+  | { kind: 'empty'; reason: TWccEmptyReason; emptyState: IWccEmptyState };
+
+export type TWccPropertyKind = 'String' | 'Number' | 'Boolean' | 'Enum' | 'Object' | 'Array';
+
+/** A scalar property value the properties panel can show and set directly. */
+export type TWccPropertyScalar = string | number | boolean | null;
+
+export interface IWccPropertyDescriptor {
+  name: string;
+  kind: TWccPropertyKind;
+  /** The values of an `Enum` property. */
+  enumValues?: string[];
+  /** The current value of a String, Number, Boolean or Enum property. */
+  value?: TWccPropertyScalar;
+  /** The current value of an Object or Array property, as formatted JSON. */
+  json?: string;
+}
+
+export type TWccPropertyListing =
+  | { kind: 'properties'; elementName: string; properties: IWccPropertyDescriptor[] }
+  | { kind: 'unavailable'; reason: string };
+
+export type TWccPropertyEditResult = { ok: true } | { ok: false; error: string };
+
+export interface IWccRenderedEvent {
+  type: 'rendered';
+  selection: IWccSelection | null;
+  outcome: TWccRenderOutcome;
+}
+
+export type TWccPreviewEvent = IWccRenderedEvent;
+
+export interface IWccPreviewBridge {
+  getManifest(): IWccCatalogManifest;
+  /** The selection rendered last, or null before the first render. */
+  getSelection(): IWccSelection | null;
+  getTheme(): TWccTheme;
+  /** Render a demo or page into the preview document, without reloading it. */
+  render(selectionArg: IWccSelection): Promise<TWccRenderOutcome>;
+  setTheme(themeArg: TWccTheme): Promise<void>;
+  /** The editable properties of the selected element's rendered instance, once it has rendered. */
+  getProperties(): Promise<TWccPropertyListing>;
+  setProperty(nameArg: string, valueArg: TWccPropertyScalar): TWccPropertyEditResult;
+  /** Parse JSON in the preview document and assign it to an Object or Array property. */
+  setPropertyJson(nameArg: string, jsonArg: string): TWccPropertyEditResult;
+  /** The rendered instance of the selected element, for same-origin tooling. */
+  findRenderedInstance(): HTMLElement | null;
+  subscribe(listenerArg: (eventArg: TWccPreviewEvent) => void): () => void;
+}
+
+/** The message a preview document posts to its parent once its bridge is installed. */
+export interface IWccPreviewReadyMessage {
+  type: 'wcctools-preview-ready';
+}
+
+declare global {
+  interface Window {
+    wccPreview?: IWccPreviewBridge;
+  }
+}

package/ts_interfaces/catalog.ts

@@ -0,0 +1,37 @@
+/**
+ * The data-only description of a catalog that the preview runtime hands to the shell.
+ * Element classes and template factories stay in the preview document.
+ */
+
+/** How the entries of a section are rendered: element demos or page factories. */
+export type TWccSectionType = 'elements' | 'pages';
+
+/** A navigable catalog entry. */
+export interface IWccManifestEntry {
+  name: string;
+  /** The registered tag of an element; null for pages and unregistered element classes. */
+  tagName: string | null;
+  /** Number of demos (always 1 for a page). */
+  demoCount: number;
+  demoGroups: string[];
+}
+
+/** A registered element without a usable demo; listed, never navigable. */
+export interface IWccManifestEntryWithoutDemo {
+  name: string;
+  tagName: string | null;
+}
+
+export interface IWccManifestSection {
+  name: string;
+  type: TWccSectionType;
+  icon?: string;
+  collapsed?: boolean;
+  /** Classified, filtered and sorted as the section configures it. */
+  entries: IWccManifestEntry[];
+  entriesWithoutDemo: IWccManifestEntryWithoutDemo[];
+}
+
+export interface IWccCatalogManifest {
+  sections: IWccManifestSection[];
+}

package/ts_interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from './catalog.js';
+export * from './bridge.js';
+export * from './requests.js';
+export * from './standard.js';

package/ts_interfaces/plugins.ts

@@ -0,0 +1,3 @@
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export { typedrequestInterfaces };

package/ts_interfaces/requests.ts

@@ -0,0 +1,65 @@
+import * as plugins from './plugins.js';
+
+/**
+ * Typed requests the shell sends to the `wcctools dev` server on `/wcctools/typedrequest`.
+ */
+
+export interface IWccDevServerInfo {
+  /** Version of the wcctools package that serves the shell. */
+  wcctoolsVersion: string;
+  /** Name of the served project's package. */
+  projectName: string;
+}
+
+export interface IReq_GetDevServerInfo
+  extends plugins.typedrequestInterfaces.implementsTR<
+    plugins.typedrequestInterfaces.ITypedRequest,
+    IReq_GetDevServerInfo
+  > {
+  method: 'getDevServerInfo';
+  request: {};
+  response: IWccDevServerInfo;
+}
+
+/** The state of a catalog bundle: its latest run started, finished or failed. */
+export type TWccBundleState = 'started' | 'finished' | 'failed';
+
+/** The status of one catalog bundle the dev server builds with tswatch. */
+export interface IWccBundleStatus {
+  /** The bundle's name in the tswatch configuration. */
+  name: string;
+  /** The latest run: `started` while it runs, then `finished` or `failed`. */
+  state: TWccBundleState;
+  /** Milliseconds the latest completed run took; absent before a run completed. */
+  durationMs?: number;
+  /**
+   * The bundler's error message when the latest completed run failed. It stays while the next
+   * run is in progress, so a failure is reported until a run finishes.
+   */
+  errorMessage?: string;
+}
+
+/** The status of every catalog bundle, at a revision that changes with every bundle event. */
+export interface IWccBundleStatusSnapshot {
+  revision: number;
+  bundles: IWccBundleStatus[];
+}
+
+/**
+ * Reads the bundle status. With `afterRevision`, the server answers once the status differs from
+ * that revision, or with the unchanged status after its wait limit, so a client follows the
+ * status with one request at a time. While the server is not serving (it is stopping), the request
+ * is refused with a typed error.
+ */
+export interface IReq_GetBundleStatus
+  extends plugins.typedrequestInterfaces.implementsTR<
+    plugins.typedrequestInterfaces.ITypedRequest,
+    IReq_GetBundleStatus
+  > {
+  method: 'getBundleStatus';
+  request: {
+    /** The revision the client knows; omitted: answer at once. */
+    afterRevision?: number;
+  };
+  response: IWccBundleStatusSnapshot;
+}

package/ts_interfaces/standard.ts

@@ -0,0 +1,103 @@
+/**
+ * The wcctools component standard (docs/standard.md): its configuration in `.smartconfig.json`
+ * and the reports `wcctools check` and `wcctools fix` produce.
+ */
+
+/** Rule set a repository adopts. */
+export type TStandardProfile = 'base' | 'dees';
+
+/** A rule id of the form `<area>/<name>`, e.g. `props/reflect-primitive`. */
+export type TStandardRuleId = string;
+
+export type TStandardSeverity = 'error' | 'warn' | 'info';
+
+/**
+ * What `wcctools fix` does for a rule:
+ * - `auto`: fixes it on every run;
+ * - `opt-in`: fixes it only when the rule is named with `--rule`;
+ * - `none`: reports only.
+ */
+export type TStandardFixMode = 'auto' | 'opt-in' | 'none';
+
+/** `.smartconfig.json` → `@design.estate/wcctools` → `standard`. */
+export interface IStandardConfig {
+  /** Rule set; 'base' when absent. */
+  profile?: TStandardProfile;
+  /** Tag prefix without the trailing hyphen, e.g. 'dees'. */
+  tagPrefix: string;
+  /** dees profile: display name per group area, e.g. { harness: 'Agent Chat' }. */
+  groupNames?: Record<string, string>;
+  /** Exact exceptions: rule id → '<file>#<member>' → '<category>: <reason>'. */
+  allowlist?: Record<TStandardRuleId, Record<string, string>>;
+  /** Accepted counts of error findings: rule id → file → count. Only shrinks. */
+  baselines?: Record<TStandardRuleId, Record<string, number>>;
+}
+
+/** `.smartconfig.json` → `@design.estate/wcctools`. */
+export interface IWccToolsConfig {
+  standard?: IStandardConfig;
+}
+
+export interface IStandardFinding {
+  ruleId: TStandardRuleId;
+  severity: TStandardSeverity;
+  /** Path relative to the repository root, '/' separators. */
+  file: string;
+  /** 1-based. */
+  line: number;
+  /** 1-based. */
+  column: number;
+  message: string;
+  /** True when `wcctools fix` resolves this finding (for opt-in rules: with --rule). */
+  fixable: boolean;
+  /** Set when the finding is covered by the allowlist or a baseline and does not fail check. */
+  covered?: 'allowlist' | 'baseline';
+}
+
+/** A file whose finding count is below its baseline: a candidate for lowering the baseline. */
+export interface IStandardBaselineSlack {
+  ruleId: TStandardRuleId;
+  file: string;
+  baseline: number;
+  current: number;
+}
+
+export interface IStandardReport {
+  profile: TStandardProfile;
+  findings: IStandardFinding[];
+  /** Files whose count is below their baseline: candidates for --update-baseline. */
+  baselineSlack: IStandardBaselineSlack[];
+  /** True when no error finding remains outside the allowlist and baselines. */
+  ok: boolean;
+}
+
+/** A rule as it applies in one profile. */
+export interface IStandardRuleInfo {
+  id: TStandardRuleId;
+  severity: TStandardSeverity;
+  fixMode: TStandardFixMode;
+  /** Categories an allowlist entry for this rule may use; empty when the rule takes no allowlist. */
+  allowlistCategories: string[];
+}
+
+export interface IStandardFileMove {
+  from: string;
+  to: string;
+}
+
+/** The changes a `wcctools fix` run makes (or, with --dry-run, would make). */
+export interface IStandardFixPlan {
+  /** `git mv` operations, from the original path to the final path. */
+  moves: IStandardFileMove[];
+  /** New files, by final path. */
+  created: string[];
+  /** Changed existing files, by final path, with the rules that changed them. */
+  edited: Array<{ file: string; ruleIds: TStandardRuleId[] }>;
+}
+
+export interface IStandardFixResult {
+  dryRun: boolean;
+  plan: IStandardFixPlan;
+  /** The check after the fix (with --dry-run: as the fix would leave the repository). */
+  remaining: IStandardReport;
+}

package/ts_shared/index.ts

@@ -0,0 +1 @@
+export * from './previewroute.js';

package/ts_shared/plugins.ts

@@ -0,0 +1,3 @@
+import * as interfaces from '../ts_interfaces/index.js';
+
+export { interfaces };

package/ts_shared/previewroute.ts

@@ -0,0 +1,58 @@
+import * as plugins from './plugins.js';
+
+/**
+ * The address of a preview document: the path the `wcctools dev` server serves it on, and
+ * the query that names what it renders. The shell loads it into its iframe; headless tools
+ * load it directly to render one demo alone.
+ */
+
+/** The path `wcctools dev` serves the preview document on. */
+export const previewRoutePath = '/wcctools-preview';
+
+export interface IWccPreviewRoute {
+  selection: plugins.interfaces.IWccSelection | null;
+  theme: plugins.interfaces.TWccTheme;
+}
+
+const queryKeys = {
+  section: 'section',
+  item: 'item',
+  demo: 'demo',
+  theme: 'theme',
+} as const;
+
+/** The query string (with leading `?`) of a preview route. */
+export const formatPreviewQuery = (routeArg: IWccPreviewRoute): string => {
+  const params = new URLSearchParams();
+  if (routeArg.selection) {
+    params.set(queryKeys.section, routeArg.selection.sectionName);
+    params.set(queryKeys.item, routeArg.selection.itemName);
+    params.set(queryKeys.demo, String(routeArg.selection.demoIndex));
+  }
+  params.set(queryKeys.theme, routeArg.theme);
+  return `?${params.toString()}`;
+};
+
+/** Read a preview route from a query string. Missing or invalid parts read as no selection and the dark theme. */
+export const parsePreviewQuery = (searchArg: string): IWccPreviewRoute => {
+  const params = new URLSearchParams(searchArg);
+  const theme: plugins.interfaces.TWccTheme = params.get(queryKeys.theme) === 'bright' ? 'bright' : 'dark';
+  const sectionName = params.get(queryKeys.section);
+  const itemName = params.get(queryKeys.item);
+  if (!sectionName || !itemName) {
+    return { selection: null, theme };
+  }
+  const demoIndex = Number.parseInt(params.get(queryKeys.demo) ?? '0', 10);
+  return {
+    selection: { sectionName, itemName, demoIndex: Number.isInteger(demoIndex) && demoIndex >= 0 ? demoIndex : 0 },
+    theme,
+  };
+};
+
+export const previewReadyMessage: plugins.interfaces.IWccPreviewReadyMessage = { type: 'wcctools-preview-ready' };
+
+export const isPreviewReadyMessage = (dataArg: unknown): dataArg is plugins.interfaces.IWccPreviewReadyMessage => {
+  return typeof dataArg === 'object'
+    && dataArg !== null
+    && (dataArg as { type?: unknown }).type === previewReadyMessage.type;
+};

package/ts_shell/bundlestatus.ts

@@ -0,0 +1,68 @@
+import * as plugins from './plugins.js';
+
+/** The first and the longest pause before a failed status request is sent again. */
+const retryDelayMinMs = 1_000;
+const retryDelayMaxMs = 10_000;
+
+/** Resolves after `msArg`, or at once when the signal aborts. */
+const pause = (msArg: number, signalArg: AbortSignal): Promise<void> =>
+  new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signalArg.removeEventListener('abort', done);
+      resolve();
+    };
+    const timer = setTimeout(done, msArg);
+    signalArg.addEventListener('abort', done, { once: true });
+  });
+
+/**
+ * Follows the dev server's bundle status: one `getBundleStatus` request at a time, each answered
+ * when the status changes. A failed request (the server restarting, for example) is sent again
+ * after a growing pause. `dispose()` aborts the request in flight and ends the loop.
+ */
+export class WccBundleStatusClient {
+  private abortController: AbortController | null = null;
+
+  constructor(
+    private readonly apiPath: string,
+    private readonly onStatus: (snapshotArg: plugins.interfaces.IWccBundleStatusSnapshot) => void,
+  ) {}
+
+  public start() {
+    if (this.abortController) {
+      return;
+    }
+    const abortController = new AbortController();
+    this.abortController = abortController;
+    void this.follow(abortController.signal);
+  }
+
+  public dispose() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+
+  private async follow(signalArg: AbortSignal) {
+    const request = new plugins.typedrequest.TypedRequest<plugins.interfaces.IReq_GetBundleStatus>(this.apiPath, 'getBundleStatus');
+    let revision: number | undefined;
+    let retryDelay = retryDelayMinMs;
+    while (!signalArg.aborted) {
+      try {
+        const snapshot = await request.fire({ afterRevision: revision }, { abortSignal: signalArg });
+        retryDelay = retryDelayMinMs;
+        if (!signalArg.aborted && snapshot.revision !== revision) {
+          revision = snapshot.revision;
+          this.onStatus(snapshot);
+        }
+      } catch (error) {
+        if (signalArg.aborted) {
+          return;
+        }
+        console.warn('wcctools: reading the bundle status failed; retrying', error);
+        await pause(retryDelay, signalArg);
+        retryDelay = Math.min(retryDelay * 2, retryDelayMaxMs);
+      }
+    }
+  }
+}