@likec4/core 1.27.3 → 1.28.1

package/src/compute-view/utils/relationExpressionToPredicates.ts

@@ -1,15 +1,5 @@
-import { pick } from 'remeda'
 import { nonexhaustive } from '../../errors'
-import type { Element } from '../../types/element'
-import {
-  type RelationExpression,
-  type RelationWhereExpr,
-  isIncoming,
-  isInOut,
-  isOutgoing,
-  isRelation,
-  isRelationWhere,
-} from '../../types/expression'
+import { ModelLayer } from '../../types'
 import { whereOperatorAsPredicate } from '../../types/operators'
 import type { ModelRelation } from '../../types/relation'
 import type { ComputedNode } from '../../types/view'
@@ -22,10 +12,13 @@ export type FilterableEdge = Pick<ModelRelation, 'kind' | 'tags'> & {
 }
 
 export function relationExpressionToPredicates<T extends FilterableEdge>(
-  expr: RelationExpression | RelationWhereExpr,
+  expr: ModelLayer.AnyRelationExpr,
 ): Predicate<T> {
   switch (true) {
-    case isRelationWhere(expr): {
+    case ModelLayer.RelationExpr.isCustom(expr): {
+      return relationExpressionToPredicates(expr.customRelation.expr)
+    }
+    case ModelLayer.RelationExpr.isWhere(expr): {
       const predicate = relationExpressionToPredicates(expr.where.expr)
       const where = whereOperatorAsPredicate(expr.where.condition)
       return e =>
@@ -36,7 +29,7 @@ export function relationExpressionToPredicates<T extends FilterableEdge>(
           ...(e.kind && { kind: e.kind }),
         })
     }
-    case isRelation(expr): {
+    case ModelLayer.RelationExpr.isDirect(expr): {
       const isSource = elementExprToPredicate(expr.source)
       const isTarget = elementExprToPredicate(expr.target)
       return edge => {
@@ -44,15 +37,15 @@ export function relationExpressionToPredicates<T extends FilterableEdge>(
           || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
       }
     }
-    case isInOut(expr): {
+    case ModelLayer.RelationExpr.isInOut(expr): {
       const isInOut = elementExprToPredicate(expr.inout)
       return edge => isInOut(edge.source) || isInOut(edge.target)
     }
-    case isIncoming(expr): {
+    case ModelLayer.RelationExpr.isIncoming(expr): {
       const isTarget = elementExprToPredicate(expr.incoming)
       return edge => isTarget(edge.target)
     }
-    case isOutgoing(expr): {
+    case ModelLayer.RelationExpr.isOutgoing(expr): {
       const isSource = elementExprToPredicate(expr.outgoing)
       return edge => isSource(edge.source)
     }

package/src/compute-view/utils/uniqueTags.ts

@@ -1,7 +1,7 @@
 import { flatMap, hasAtLeast, pipe, sort, unique } from 'remeda'
 import type { LiteralUnion } from 'type-fest'
 import type { NonEmptyReadonlyArray } from '../../types/_common'
-import type { Tag } from '../../types/element'
+import type { Tag } from '../../types/scalars'
 import { compareNatural } from '../../utils/compare-natural'
 
 /**
@@ -9,13 +9,13 @@ import { compareNatural } from '../../utils/compare-natural'
  * and sort in natural order; returns null if no tags are present.
  */
 export function uniqueTags<T extends { tags?: NonEmptyReadonlyArray<LiteralUnion<Tag, string>> | null }>(
-  elements: ReadonlyArray<T>
+  elements: ReadonlyArray<T>,
 ) {
   const tags = pipe(
     elements,
     flatMap(e => e.tags ?? []),
     unique(),
-    sort(compareNatural)
+    sort(compareNatural),
   )
   return hasAtLeast(tags, 1) ? tags as NonEmptyReadonlyArray<Tag> : null
 }

package/src/index.ts

@@ -33,8 +33,6 @@ export * from './types'
 
 export * from './utils'
 
-export * as Expr from './types/expression'
-
 export {
   computeView,
   computeViews,

package/src/model/ElementModel.ts

@@ -1,19 +1,23 @@
 import { isTruthy } from 'remeda'
 import type { SetRequired } from 'type-fest'
+import type { IteratorLike } from '../types/_common'
 import {
   type Element as C4Element,
   type ElementKind as C4ElementKind,
   type ElementShape as C4ElementShape,
   type ElementStyle,
-  type IconUrl,
-  type IteratorLike,
   type Link,
-  type Tag as C4Tag,
-  type ThemeColor,
   DefaultElementShape,
   DefaultThemeColor,
-} from '../types'
+} from '../types/element'
 import { DefaultShapeSize } from '../types/element'
+import {
+  type IconUrl,
+  type ProjectId,
+  type Tag as C4Tag,
+  splitGlobalFqn,
+} from '../types/scalars'
+import type { ThemeColor } from '../types/theme'
 import { commonAncestor, hierarchyLevel, isAncestor, sortNaturalByFqn } from '../utils'
 import { type DeployedInstancesIterator } from './DeploymentElementModel'
 import type { LikeC4Model } from './LikeC4Model'
@@ -28,13 +32,28 @@ export class ElementModel<M extends AnyAux = AnyAux> {
   readonly _literalId: M['Element']
   readonly hierarchyLevel: number
 
+  readonly imported: null | {
+    from: ProjectId
+    fqn: string
+  }
+
   constructor(
     public readonly $model: LikeC4Model<M>,
     public readonly $element: C4Element,
   ) {
     this.id = this.$element.id
     this._literalId = this.$element.id
-    this.hierarchyLevel = hierarchyLevel(this.id)
+    const [projectId, fqn] = splitGlobalFqn(this.id)
+    if (projectId) {
+      this.imported = {
+        from: projectId,
+        fqn,
+      }
+      this.hierarchyLevel = hierarchyLevel(fqn)
+    } else {
+      this.imported = null
+      this.hierarchyLevel = hierarchyLevel(this.id)
+    }
   }
 
   get parent(): ElementModel<M> | null {

package/src/model/LikeC4Model.ts

@@ -1,15 +1,17 @@
-import { mapValues, pipe, sort, values } from 'remeda'
+import { entries, mapValues, pipe, sort, values } from 'remeda'
 import type { LiteralUnion } from 'type-fest'
 import { computeView, unsafeComputeView } from '../compute-view'
 import type { ComputeViewResult } from '../compute-view/compute-view'
 import { invariant, nonNullable } from '../errors'
-import type { ComputedView, DiagramView, IteratorLike, LikeC4View, ModelGlobals } from '../types'
+import type { IteratorLike } from '../types/_common'
 import type { Element } from '../types/element'
-import { type Tag as C4Tag } from '../types/element'
+import type { ModelGlobals } from '../types/global'
 import type { AnyParsedLikeC4ModelData, GenericLikeC4ModelData, LikeC4ModelDump } from '../types/model-data'
 import type { ModelRelation } from '../types/relation'
+import { type ProjectId, type Tag as C4Tag, GlobalFqn, isGlobalFqn } from '../types/scalars'
+import type { ComputedView, DiagramView, LikeC4View } from '../types/view'
 import { compareNatural } from '../utils'
-import { ancestorsFqn, commonAncestor, parentFqn } from '../utils/fqn'
+import { ancestorsFqn, commonAncestor, parentFqn, sortParentsFirst } from '../utils/fqn'
 import { DefaultMap } from '../utils/mnemonist'
 import type {
   DeployedInstanceModel,
@@ -121,6 +123,14 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
         this.#allTags.get(tag).add(el)
       }
     }
+    for (const [projectId, elements] of entries($model.imports)) {
+      for (const element of sortParentsFirst(elements)) {
+        const el = this.addImportedElement(projectId as ProjectId, element)
+        for (const tag of el.tags) {
+          this.#allTags.get(tag).add(el)
+        }
+      }
+    }
     for (const relation of values($model.relations)) {
       const el = this.addRelation(relation)
       for (const tag of el.tags) {
@@ -365,7 +375,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     if (this.#elements.has(element.id)) {
       throw new Error(`Element ${element.id} already exists`)
     }
-    const el = new ElementModel(this, Object.freeze(structuredClone(element)))
+    const el = new ElementModel(this, Object.freeze(element))
     this.#elements.set(el.id, el)
     const parentId = parentFqn(el.id)
     if (parentId) {
@@ -378,13 +388,42 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
     return el
   }
 
+  private addImportedElement(projectId: ProjectId, element: Element) {
+    invariant(!isGlobalFqn(element.id), `Imported element already has global FQN`)
+    const id = GlobalFqn(projectId, element.id)
+    if (this.#elements.has(id)) {
+      throw new Error(`Element ${id} already exists`)
+    }
+    const el = new ElementModel(
+      this,
+      Object.freeze({
+        ...element,
+        id,
+      }),
+    )
+    this.#elements.set(el.id, el)
+    let parentId = parentFqn(el.id)
+    while (parentId) {
+      // For imported elements - id has format `@projectId.fqn`
+      // We need to exclude `@projectId` from the parentId
+      if (parentId.includes('.') && this.#elements.has(parentId)) {
+        this.#parents.set(el.id, this.element(parentId))
+        this.#children.get(parentId).add(el)
+        return el
+      }
+      parentId = parentFqn(parentId)
+    }
+    this.#rootElements.add(el)
+    return el
+  }
+
   private addRelation(relation: ModelRelation) {
     if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`)
     }
     const rel = new RelationshipModel(
       this,
-      Object.freeze(structuredClone(relation)),
+      Object.freeze(relation),
     )
     const { source, target } = rel
     this.#relations.set(rel.id, rel)
@@ -418,6 +457,7 @@ export class LikeC4Model<M extends AnyAux = LikeC4Model.Any> {
 
 export namespace LikeC4Model {
   export const EMPTY = LikeC4Model.create({
+    projectId: 'default' as ProjectId,
     specification: {
       elements: {},
       relationships: {},
@@ -436,6 +476,7 @@ export namespace LikeC4Model {
     elements: {},
     relations: {},
     views: {},
+    imports: {},
   }) as LikeC4Model<AnyAux>
 
   export type Any = Aux<

package/src/model/RelationModel.ts

@@ -1,12 +1,14 @@
 import { isEmpty } from 'remeda'
-import type { Color, IteratorLike } from '../types'
-import type { Link, Tag } from '../types/element'
+import type { IteratorLike } from '../types/_common'
+import type { Link } from '../types/element'
 import {
   type ModelRelation,
   type RelationshipLineType,
   DefaultLineStyle,
   DefaultRelationshipColor,
 } from '../types/relation'
+import type { Tag } from '../types/scalars'
+import type { Color } from '../types/theme'
 import { commonAncestor } from '../utils/fqn'
 import type { DeploymentRelationModel } from './DeploymentElementModel'
 import type { ElementModel } from './ElementModel'

package/src/model/view/LikeC4ViewModel.ts

@@ -1,6 +1,7 @@
 import { nonNullable } from '../../errors'
-import type { IteratorLike } from '../../types'
-import type { Link, Tag } from '../../types/element'
+import type { IteratorLike } from '../../types/_common'
+import type { Link } from '../../types/element'
+import type { Tag } from '../../types/scalars'
 import {
   type ComputedDeploymentView,
   type ComputedDynamicView,

package/src/types/_common.ts

@@ -1,13 +1,9 @@
 import type { Simplify, Tagged, UnionToIntersection } from 'type-fest'
 
-export type ProjectId = Tagged<string, 'ProjectID'>
-
 export type NonEmptyArray<T> = [T, ...T[]]
 
 export type NonEmptyReadonlyArray<T> = readonly [T, ...T[]]
 
-export type IconUrl = Tagged<string, 'IconUrl'> | 'none'
-
 export type CustomColor = string
 
 export type Point = readonly [x: number, y: number]

package/src/types/deployments.ts

@@ -1,7 +1,8 @@
 import type { MergeExclusive, Simplify, Tagged } from 'type-fest'
-import type { IconUrl, NonEmptyArray } from './_common'
-import type { ElementShape, ElementStyle, Fqn, Link, Tag } from './element'
+import type { NonEmptyArray } from './_common'
+import type { ElementShape, ElementStyle, Link } from './element'
 import type { AbstractRelation, RelationId } from './relation'
+import type { Fqn, IconUrl, Tag } from './scalars'
 import type { Color } from './theme'
 
 export type DeploymentNodeKind<Kinds extends string = string> = Tagged<Kinds, 'DeploymentNodeKind'>

package/src/types/element.ts

@@ -1,14 +1,8 @@
 import type { Tagged, TupleToUnion } from 'type-fest'
-import type { IconUrl, NonEmptyArray } from './_common'
+import type { NonEmptyArray } from './_common'
+import type { Fqn, IconUrl, Tag } from './scalars'
 import type { Color, ShapeSize, SpacingSize, TextSize, ThemeColor } from './theme'
 
-// Full-qualified-name
-export type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>
-
-export function AsFqn(name: string, parent?: Fqn | null) {
-  return (parent ? parent + '.' + name : name) as Fqn
-}
-
 export const BorderStyles = ['solid', 'dashed', 'dotted', 'none'] as const
 
 export type BorderStyle = TupleToUnion<typeof BorderStyles>
@@ -60,8 +54,6 @@ export interface ElementStyle {
   readonly textSize?: TextSize
 }
 
-export type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>
-
 export interface TagSpec {
   readonly id: Tag
   readonly style: ElementStyle

package/src/types/expression-v2-model.ts

@@ -0,0 +1,314 @@
+import type { ExclusiveUnion } from './_common'
+import type { PredicateSelector } from './deployments'
+import type { BorderStyle, ElementKind, ElementShape } from './element'
+import type { WhereOperator } from './operators'
+import type { RelationshipArrowType, RelationshipLineType } from './relation'
+import { type Fqn, type IconUrl, type ProjectId, type Tag, GlobalFqn } from './scalars'
+import type { Color, ShapeSize } from './theme'
+import type { ViewId } from './view'
+
+export namespace ModelLayer {
+  export namespace FqnRef {
+    /**
+     * Reference to logical model element
+     */
+    export type ModelRef<F = Fqn> = {
+      model: F
+    }
+    export const isModelRef = (ref: FqnRef): ref is ModelRef => {
+      return 'model' in ref && !('project' in ref)
+    }
+
+    /**
+     * Reference to imported logical model element
+     */
+    export type ImportRef<F = Fqn> = {
+      project: ProjectId
+      model: F
+    }
+    export const isImportRef = (ref: FqnRef): ref is ImportRef => {
+      return 'project' in ref && 'model' in ref
+    }
+
+    export const toFqn = (ref: FqnRef): Fqn => {
+      if (isImportRef(ref)) {
+        return GlobalFqn(ref.project, ref.model)
+      }
+      if (isModelRef(ref)) {
+        return ref.model
+      }
+      throw new Error('Expected FqnRef.ModelRef or FqnRef.ImportRef')
+    }
+  }
+
+  export type FqnRef<M = Fqn> = ExclusiveUnion<{
+    ModelRef: FqnRef.ModelRef<M>
+    ImportRef: FqnRef.ImportRef<M>
+  }>
+
+  export namespace FqnExpr {
+    export type Wildcard = {
+      wildcard: true
+    }
+    export const isWildcard = (expr: Expression): expr is FqnExpr.Wildcard => {
+      return 'wildcard' in expr && expr.wildcard === true
+    }
+
+    export type ModelRef<M = Fqn> = {
+      ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>
+      selector?: PredicateSelector
+    }
+    export const isModelRef = (ref: Expression): ref is FqnExpr.ModelRef => {
+      return 'ref' in ref
+    }
+
+    export type ElementKindExpr = {
+      elementKind: ElementKind
+      isEqual: boolean
+    }
+    export function isElementKindExpr(expr: Expression): expr is ElementKindExpr {
+      return 'elementKind' in expr && 'isEqual' in expr
+    }
+
+    export type ElementTagExpr = {
+      elementTag: Tag
+      isEqual: boolean
+    }
+    export function isElementTagExpr(expr: Expression): expr is ElementTagExpr {
+      return 'elementTag' in expr && 'isEqual' in expr
+    }
+
+    export type NonWildcard<M = Fqn> = ExclusiveUnion<{
+      ModelRef: ModelRef<M>
+      ElementKind: ElementKindExpr
+      ElementTag: ElementTagExpr
+    }>
+
+    export type Where<M = Fqn> = {
+      where: {
+        expr: ExclusiveUnion<{
+          Wildcard: Wildcard
+          ModelRef: ModelRef<M>
+          ElementKind: ElementKindExpr
+          ElementTag: ElementTagExpr
+        }>
+        condition: WhereOperator<string, string>
+      }
+    }
+
+    export const isWhere = (expr: Expression): expr is FqnExpr.Where => {
+      return 'where' in expr && is(expr.where.expr)
+    }
+
+    export type Custom<M = Fqn> = {
+      custom: {
+        expr: FqnExprOrWhere<M>
+        title?: string
+        description?: string
+        technology?: string
+        notation?: string
+        shape?: ElementShape
+        color?: Color
+        icon?: IconUrl
+        border?: BorderStyle
+        opacity?: number
+        navigateTo?: ViewId
+        multiple?: boolean
+        size?: ShapeSize
+        padding?: ShapeSize
+        textSize?: ShapeSize
+      }
+    }
+
+    export const isCustom = (expr: Expression): expr is FqnExpr.Custom => {
+      return 'custom' in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr))
+    }
+
+    export const is = (expr: Expression): expr is FqnExpr => {
+      return isWildcard(expr)
+        || isModelRef(expr)
+        || isElementKindExpr(expr)
+        || isElementTagExpr(expr)
+    }
+  }
+
+  export type FqnExpr<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+  }>
+
+  export type FqnExprOrWhere<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Where: FqnExpr.Where<M>
+  }>
+
+  export type AnyFqnExpr<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Where: FqnExpr.Where<M>
+    Custom: FqnExpr.Custom<M>
+  }>
+
+  export function isAnyFqnExpr(expr: Expression): expr is AnyFqnExpr {
+    return FqnExpr.is(expr)
+      || FqnExpr.isWhere(expr)
+      || FqnExpr.isCustom(expr)
+  }
+
+  export namespace RelationExpr {
+    export type Direct<M = Fqn> = {
+      source: FqnExpr<M>
+      target: FqnExpr<M>
+      isBidirectional?: boolean
+    }
+    export const isDirect = (expr: Expression): expr is RelationExpr.Direct => {
+      return 'source' in expr && 'target' in expr
+    }
+    export type Incoming<M = Fqn> = {
+      incoming: FqnExpr<M>
+    }
+    export const isIncoming = (expr: Expression): expr is RelationExpr.Incoming => {
+      return 'incoming' in expr
+    }
+    export type Outgoing<M = Fqn> = {
+      outgoing: FqnExpr<M>
+    }
+    export const isOutgoing = (expr: Expression): expr is RelationExpr.Outgoing => {
+      return 'outgoing' in expr
+    }
+    export type InOut<M = Fqn> = {
+      inout: FqnExpr<M>
+    }
+    export const isInOut = (expr: Expression): expr is RelationExpr.InOut => {
+      return 'inout' in expr
+    }
+    export type Where<M = Fqn> = {
+      where: {
+        expr: ExclusiveUnion<{
+          Direct: RelationExpr.Direct<M>
+          Incoming: RelationExpr.Incoming<M>
+          Outgoing: RelationExpr.Outgoing<M>
+          InOut: RelationExpr.InOut<M>
+        }>
+        condition: WhereOperator<string, string>
+      }
+    }
+    export const isWhere = (expr: Expression): expr is RelationExpr.Where => {
+      return 'where' in expr && is(expr.where.expr)
+    }
+
+    export type Custom<M = Fqn> = {
+      customRelation: {
+        expr: RelationExprOrWhere<M>
+        title?: string
+        description?: string
+        technology?: string
+        notation?: string
+        // Link to dynamic view
+        navigateTo?: ViewId
+        // Notes for walkthrough
+        notes?: string
+        color?: Color
+        line?: RelationshipLineType
+        head?: RelationshipArrowType
+        tail?: RelationshipArrowType
+      }
+    }
+
+    export const isCustom = (expr: Expression): expr is Custom => {
+      return 'customRelation' in expr
+    }
+
+    export const is = (expr: Expression): expr is RelationExpr => {
+      return isDirect(expr)
+        || isIncoming(expr)
+        || isOutgoing(expr)
+        || isInOut(expr)
+    }
+  }
+
+  export type RelationExpr<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+  }>
+
+  export type RelationExprOrWhere<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    Where: RelationExpr.Where<M>
+  }>
+
+  export type AnyRelationExpr<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    Where: RelationExpr.Where<M>
+    CustomRelation: RelationExpr.Custom<M>
+  }>
+
+  export function isAnyRelationExpr(expr: Expression): expr is AnyRelationExpr {
+    return RelationExpr.is(expr)
+      || RelationExpr.isWhere(expr)
+      || RelationExpr.isCustom(expr)
+  }
+
+  /**
+   * Represents a version 2 expression which can be one of several types.
+   *
+   * @template M - The type for the model FQN, defaults to `Fqn`.
+   */
+  export type Expression<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Custom: FqnExpr.Custom<M>
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    CustomRelation: RelationExpr.Custom<M>
+    Where: Expression.Where<M>
+  }>
+
+  export function isExpression(expr: any): expr is Expression {
+    return isAnyFqnExpr(expr)
+      || isAnyRelationExpr(expr)
+  }
+
+  export namespace Expression {
+    export type Where<M = Fqn> = FqnExpr.Where<M> | RelationExpr.Where<M>
+
+    export const isWhere = (expr: Expression): expr is Expression.Where => {
+      return 'where' in expr
+    }
+
+    export const isCustomFqnExpr = (expr: Expression): expr is FqnExpr.Custom => {
+      return FqnExpr.isCustom(expr)
+    }
+
+    export const isCustomRelationExpr = (expr: Expression): expr is RelationExpr.Custom => {
+      return RelationExpr.isCustom(expr)
+    }
+
+    export const isFqnExpr = (expr: Expression): expr is FqnExpr => {
+      return FqnExpr.is(expr)
+    }
+
+    export const isRelation = (expr: Expression): expr is RelationExpr => {
+      return RelationExpr.is(expr)
+    }
+  }
+}