@zenuml/core 3.47.9 → 3.48.1

package/e2e/data/compare-cases.js

@@ -1,1090 +0,0 @@
-// Single source of truth for all comparison test cases.
-// Used by both compare.html (homepage) and compare-case.html (diff viewer).
-
-export const CASES = {
-  // --- Basics ---
-  "empty": ``,
-  "single-participant": `A`,
-  "sync-call": `A.m`,
-  "simple-messages": `A -> B: hello
-B -> C: process
-C -> B: result
-B -> A: done`,
-  "named-params": `title Named Parameters Test
-// Testing named parameter syntax (param=value)
-A.method(userId=123, name="John")
-B.create(type="User", active=true)
-C.mixedCall(1, name="Mixed", enabled=false)
-D.oldStyle(1, 2, 3)
-E.complex(first="value1", second=42, third=true, fourth="final")`,
-
-  // --- Sync calls & self-calls ---
-  "nested-sync": `A.method() {
-  B.method
-}`,
-  "self-sync": `selfSync() {
-  A.method {
-    B.method
-  }
-}`,
-  "demo5-self-named": `A.methodA() { A.methodA1() }`,
-  "nested-occurrence": `title Order Service
-A.method1{
-  B.method2 {
-    A->B.method3
-  }
-}`,
-  "interaction": `if(x) {
-  A.method() {
-    B.method() {
-      BSelfMethod00000000000
-      A.method()
-    }
-    ASelf {
-      B->A.method
-    }
-  }
-}`,
-  "nested-fragment": `title Nested Interaction with Fragment and Self-Invocation
-A.Read() {
-  B.Submit() {
-    Process() {
-      if (true) {
-        ProcessCallback() {
-          A.method
-        }
-      }
-    }
-  }
-}`,
-  "nested-outbound": `title Nested Interaction with Outbound Message and Fragment
-A.Read() {
-  B.Submit() {
-    C->B.method {
-      if (true) {
-        ProcessCallback() {
-          A.method
-        }
-      }
-    }
-  }
-}`,
-  "if-then-continue": `A.m {
-  if(x) {
-    B.m
-  }
-  C.m
-}`,
-  "participant-width": `LongParticipantName.method`,
-
-  // --- Async messages ---
-  "async-1": `A->A: async
-A->B: async
-A->C: async
-B->B: async
-B->C: async
-B->A: async
-C->C: async
-C->B: async
-C->A: async`,
-  "async-2": `A.method {
-  A->A: async
-  A->B: async
-  A->C: async
-  B->B: async
-  B->C: async
-  B->A: async
-  C->C: async
-  C->B: async
-  C->A: async
-  B.method {
-    A->A: async
-    A->B: async
-    A->C: async
-    B->B: async
-    B->C: async
-    B->A: async
-    C->C: async
-    C->B: async
-    C->A: async
-  }
-}`,
-  "async-3": `A B C
-C.method {
-  A->C: async
-  C->A: async
-  C->B: async
-  B->C: async
-  B.method {
-    A->A: async
-    A->B: async
-    A->C: async
-    B->B: async
-    B->C: async
-    B->A: async
-    C->C: async
-    C->B: async
-    C->A: async
-  }
-}`,
-  "async-self": `A->A: selfAsync`,
-  "async-self-nested": `A.method {
-  A->A: async
-}`,
-  "demo6-async-styled": `A->A:: Hello
-A->B:: Hello B
-B->A: So what`,
-
-  // --- Fragments ---
-  "repro-alt-simple": `if(cond) {
-  A -> B: inIf
-} else {
-  A -> B: inElse
-}`,
-  "repro-alt-branches": `if(cond) {
-  A -> B: msg1
-} else if(cond2) {
-  A -> B: elseIfMsg
-} else {
-  A -> B: elseMsg
-}`,
-  "repro-alt-tcf-only": `if(cond) {
-  A -> B: msg1
-  try {
-    B -> C: tryMsg
-  } catch(e) {
-    C -> B: catchMsg
-  } finally {
-    B -> A: finallyMsg
-  }
-}`,
-  "repro-alt-nested-tcf": `if(cond) {
-  A -> B: msg1
-  try {
-    B -> C: tryMsg
-  } catch(e) {
-    C -> B: catchMsg
-  } finally {
-    B -> A: finallyMsg
-  }
-} else if(cond2) {
-  A -> B: elseIfMsg
-} else {
-  A -> B: elseMsg
-}`,
-  "if-fragment": `title Issue 232 - wrong layout for if-fragment
-Client -> Server:SendRequest
-
-if(true){
-  Server -> Server: processRequest
-}`,
-  "fragment-loop": `A -> B: request
-loop(condition) {
-  B -> C: process
-}`,
-  "fragment-tcf": `A.method {
-  try {
-    B.process
-  } catch(error) {
-    C.handle
-  } finally {
-    D.cleanup
-  }
-}`,
-  "fragment": `A
-B
-C #FF0000  // we style it to make it more important in image comparison
-if(x) {
-  loop(y) {
-    try {
-      par {
-        A.m();
-        B.m();
-      }
-    } catch(e) {
-      opt {
-        new C
-      }
-    } finally {
-      C.m
-    }
-  }
-}`,
-  "fragments-return": `A.method {
-  if(x) {
-    return x
-  } else {
-    return y
-  }
-  try {
-    return 1
-  } catch {
-    return 2
-  } finally {
-    return 3
-  }
-}`,
-  "fragment-issue": `// This sample is carefully crafted. It shows a known issues: fragment stretched to
-// svc (should not), because parser thinks the return statement returns to svc.
-group Backend {@VPC svc @RDS rep}
-group { Client }
-Client->SGW."Get order by id" {
-  svc.Get(id) {
-    rep."load order" {
-      if(order == null) {
-        @return
-        SGW->Client:401
-      }
-    }
-  }
-}`,
-  "nested-fragment-indent": `A.m {
-  try {
-    loop(x) {
-      B.m
-    }
-  } catch(e) {
-    B.m
-  }
-}`,
-
-  // --- Creation ---
-  "creation": `title Title 1
-A.m {
-  new B(1,2,3,4)
-}`,
-  "creation-return": `A.method() {
-  b = new B()
-}`,
-  "creation-rtl": `"b:B"
-a1 = A.method() {
-  // abcde
-  b = new B()
-}`,
-  "creation-long-name": `new AHasAVeryLongNameLongNameLongNameLongName()`,
-  "comment-creation": `A.method() {
-  // abcde
-  new B()
-}`,
-  "defect-406": `title Title 1
-A.m1 {
-  new B(1,2,3,4) {
-    if(x) {
-      C.m2
-    }
-    while(y) {
-      D.m3
-    }
-    par {
-      E.m4
-      F.m5
-    }
-    opt {
-      G.m6
-    }
-  }
-}`,
-
-  // --- Return ---
-  "return": `A B C D
-
-A->B.method() {
-  ret0_assign_rtl =C.method_long_to_give_space {
-    @return C->D: ret1_annotation_ltr
-    ret5_assign_ltr = B.method
-    B.method2 {
-      return ret2_return_ltr
-    }
-  }
-
-  return ret2_return_rtl
-  @return B->A: ret4_annotation_rtl
-}`,
-  "return-in-nested-if": `A.m {
-  if (condition) {
-    return ret
-    if(x) {
-      new B
-    }
-  }
-}`,
-  // Minimal return isolation cases
-  "return-single-explicit": `A B
-A->B.method() {
-  return ret1
-}`,
-  "return-two-explicit": `A B
-A->B.method() {
-  B.inner
-  return ret1
-  @return B->A: ret2
-}`,
-  "return-nested-then-direct": `A B C
-A->B.method() {
-  B->C.nested() {
-    return nested_ret
-  }
-  return direct_ret
-}`,
-  "return-only-two": `A B
-A->B.method() {
-  return ret1
-  @return B->A: ret2
-}`,
-  "return-assign-rtl": `A B C
-A->B.method() {
-  ret0 = C.inner {
-    B.work
-  }
-}`,
-  "return-assign-ltr": `A B C
-A->B.method() {
-  ret0 = B.inner
-}`,
-  "return-keyword-ltr": `A B C
-A->B.method() {
-  B->C.work {
-    return ret1
-  }
-}`,
-  "repro-return-after-creation": `new B() {
-  return from_creation
-}
-return "back to caller"`,
-
-  // --- Vertical layout (comments & creation) ---
-  "vertical-1": `// red
-// green
-a = A.m111
-new E`,
-  "vertical-2": `// [red]
-new B`,
-  "vertical-3": `if(x) {
-  // comment
-  new A
-} else {
-  new B
-}
-
-new C
-try {
-  new D
-} catch {
-  par {
-    new E
-    new F
-  }
-}`,
-  "vertical-4": `if(x) {
-  // comment
-  new A
-} else {
-  new B
-}
-
-new C
-try {
-  new D
-} catch {
-  par {
-    new E
-    new F
-    if(x) {
-      new X
-    } else {
-      new Y
-    }
-  }
-}`,
-  "vertical-5": `par {
-  new F
-  if(x) {
-    new X
-  } else {
-    try {
-      new Y
-    } catch {
-      par {
-        new G
-        if(x) {
-          new H
-        } else {
-          new I
-        }
-      }
-    }
-  }
-}`,
-  "vertical-6": `new a
-if(x) {
-\tnew b
-} else {
-\tnew c
-\tnew e
-}
-new D`,
-  "vertical-7": `A.method
-section(){
-    new B
-}`,
-  "vertical-8": `new Creation() {
-  return from_creation
-}
-return "from if to original source"
-try {
-  new AHasAVeryLongNameLongNameLongNameLongName() {
-    new CreatWithinCreat()
-  }
-}`,
-  "vertical-9": `A0->A0: self
-new A`,
-  "vertical-10": `new E
-E.messageA()
-new A {
-  if (x) {
-    new D
-  }
-  new B {
-    new C
-  }
-}`,
-  "vertical-11": `A.call {
-  // pre creation
-  A->B: prep
-  a = new A()
-  a->B: post
-}`,
-
-  // --- Complex demos ---
-  "smoke": `title ABCD Title
-// Generating Sequence Diagrams from Java code is experimental.
-// Please report errors to https://github.com/ZenUml/jetbrains-zenuml/discussions
-MarkdownJavaFxHtmlPanel
-MarkdownJavaFxHtmlPanel.readFromInputStream(inputStream) {
-  StringBuilder resultStringBuilder = new StringBuilder();
-  try {
-    // String line;
-    while((line = br.readLine()) != null) {
-      resultStringBuilder.append(line);
-    }
-  }
-  catch(IOException) {
-    return "";
-  }
-  return "resultStringBuilder.toString()";
-}`,
-  "demo1-smoke": `// comments at the beginning should be ignored
-title This is a title
-@Lambda <<stereotype>> ParticipantName
-group "B C" {@EC2 B @ECS C}
-"bg color" #FF0000
-@Starter("OptionalStarter")
-new B
-ReturnType ret = ParticipantName.methodA(a, b) {
-  critical("This is a critical message") {
-    // Customised style for RESTFul API - \`POST /order\`
-    ReturnType ret2 = selfCall() {
-      B.syncCallWithinSelfCall() {
-        ParticipantName.rightToLeftCall()
-        return B
-      }
-      "space in name"->"bg color".syncMethod(from, to)
-    }
-  }
-  // A comment for alt
-  if (condition) {
-    // A comment for creation
-    ret = new CreatAndAssign()
-    "ret:CreatAndAssign".method(create, and, assign)
-    // A comment for async self
-    B->B: Self Async
-    // A comment for async message
-    B->C: Async Message within fragment
-    new Creation() {
-      return from_creation
-    }
-    return "from if to original source"
-    try {
-      new AHasAVeryLongNameLongNameLongNameLongName() {
-        new CreatWithinCreat()
-        C.rightToLeftFromCreation() {
-          B.FurtherRightToLeftFromCreation()
-        }
-      }
-    } catch (Exception) {
-      self {
-        return C
-      }
-    } finally {
-      C: async call from implied source
-    }
-    =====divider can be anywhere=====
-  } else if ("another condition") {
-    par {
-      B.method
-      C.method
-    }
-  } else {
-    // A comment for loop
-    forEach(Z) {
-      Z.method() {
-        return Z
-      }
-    }
-  }
-}`,
-  "demo3-nested-fragments": `ret = A.methodA() {
-  if (x) {
-    B.methodB()
-    if (y) {
-      C.methodC()
-    }
-  }
-  while (x) {
-    B.methodB()
-    while (y) {
-      C.methodC()
-    }
-  }
-  if (x) {
-    method()
-    if (y) {
-      method2()
-    }
-  }
-  while (x) {
-    method()
-    while (y) {
-      method2()
-    }
-  }
-  while (x) {
-    method()
-    if (y) {
-      method2()
-    }
-  }
-  if (x) {
-    method()
-    while (y) {
-      method2()
-    }
-  }
-}`,
-  "demo4-fragment-span": `ret = A.methodA() {
-  B.method() {
-    if (X) {
-      C.methodC() {
-        a = A.methodA() {
-          D.method()
-        }
-      }
-    }
-    while (Y) {
-      C.methodC() {
-        A.methodA()
-      }
-    }
-   }
- }`,
-
-  // --- Repro cases ---
-  "repro-participant-y": `A -> B: hello`,
-  "repro-occ-basics": `A.method()`,
-  "repro-occ-height": `A.B {
-  B.C {
-    C.D
-  }
-  B.E
-}`,
-  "repro-creation-width": `A.m {
-  b = new LongParticipantName()
-}`,
-  "repro-comment": `A.method {
-  try {
-    // String line;
-    B.process
-  } catch(e) {
-    C.handle
-  }
-}`,
-  "repro-msg-y": `A -> B: msg`,
-  "repro-occ-depth2": `A.method() {
-  selfCall() {
-    B.call() {
-      A.rtl()
-    }
-  }
-}`,
-  "repro-comment-async-self": `A.method() {
-  // A comment
-  A->A: Self Async
-}`,
-  "repro-debt-drift": `A.method() {
-  selfCall() {
-    B.call() {
-      A.rtl()
-      return B
-    }
-  }
-  B.syncMethod(from,to)
-}`,
-  "repro-fragment-section-debt": `A.method() {
-  if(x) {
-    B.call() {
-      return result
-    }
-  } else {
-    B.afterSection()
-  }
-}`,
-  "repro-creation-in-try": `A.method() {
-  try {
-    b = new B() {
-      B.inner()
-    }
-    A.afterCreation()
-  } catch(Exception) {
-    A.inCatch()
-  } finally {
-    A.inFinally()
-  }
-}`,
-
-  // --- Occurrence bar length ---
-  "occ-bar-length": `A->B.method {
-  B->C.inner {
-    @return C->B: ret1
-    B->C.call2 {
-      return ret2
-    }
-  }
-  return ret3
-}`,
-
-  // --- Return Y after inner block ---
-  "return-after-block": `A->B.method {
-  B->C.inner {
-    @return C->B: ret_inside
-    C->B.call2
-    B->C.call3 {
-      return ret_nested
-    }
-  }
-  return ret_after
-  @return B->A: ret_annot
-}`,
-
-  // --- Assignment return: block with inner return ---
-  "repro-assign-return": `A->B.method {
-  ret0 = B->C.inner {
-    @return C->B: ret_inside
-  }
-}`,
-  // --- Occurrence height: empty block (no children) ---
-  "repro-occ-empty": `A->B.method {
-  B->C.inner {
-  }
-}`,
-  // --- Occurrence height: block with one sync message ---
-  "repro-occ-sync": `A->B.method {
-  B->C.inner {
-    C->B.call
-  }
-}`,
-  // --- Occurrence height: block with one non-self return ---
-  "repro-occ-return": `A->B.method {
-  B->C.inner {
-    @return C->B: ret
-  }
-}`,
-  // --- Occurrence height: block with sync + return ---
-  "repro-occ-mixed": `A->B.method {
-  B->C.inner {
-    C->B.call
-    @return C->B: ret
-  }
-}`,
-  // --- Occurrence height: sync + `return` keyword ---
-  "repro-occ-mixed-keyword": `A->B.method {
-  B->C.inner {
-    C->B.call
-    return ret_kw
-  }
-}`,
-  // --- Occurrence height: sync + two @returns ---
-  "repro-occ-mixed-2ret": `A->B.method {
-  B->C.inner {
-    C->B.call
-    @return C->B: ret1
-    @return C->B: ret2
-  }
-}`,
-  // --- Occurrence height: two syncs + one @return between them ---
-  "repro-occ-mixed-mid": `A->B.method {
-  B->C.inner {
-    C->B.call1
-    @return C->B: ret
-    C->B.call2
-  }
-}`,
-  // --- Creation with params ---
-  "repro-creation-params": `new B(1)`,
-  // --- Just participant B (no creation) ---
-  "repro-just-B": `B`,
-  // --- Starter + B with message ---
-  "repro-starter-B": `B.m`,
-  // --- Starter + B with long method name ---
-  "repro-starter-B-long": `B.aVeryLongMethodThatShouldPushTheParticipant`,
-  // --- Participant colors on supported icons ---
-  "repro-color-boundary": `@Actor Client #FFEBE6
-@Boundary OrderController #0747A6
-Client->OrderController: post`,
-  // --- Stereotype + color + EC2 icon header layout ---
-  "repro-ec2-stereotype-color": `@EC2 <<BFF>> OrderService #E3FCEF
-OrderService.create(payload)`,
-  // --- Cloud service icons without group geometry ---
-  "repro-service-icons": `@Lambda PurchaseService
-@AzureFunction InvoiceService
-PurchaseService->InvoiceService: createInvoice(order)`,
-  // --- Group container without unsupported icon noise ---
-  "repro-group-container": `group BusinessService {
-  @Actor Client
-  @Boundary OrderController
-}
-Client->OrderController: post`,
-
-  // --- Order Service (comments + nested fragments) ---
-  "order-service": `title Order Service
-@Actor Client #FFEBE6
-@Boundary OrderController #0747A6
-@EC2 <<BFF>> OrderService #E3FCEF
-group BusinessService {
-  @Lambda PurchaseService
-  @AzureFunction InvoiceService
-}
-@Starter(Client)
-// \`POST /orders\`
-OrderController.post(payload) {
-  // comment to
-  OrderService.create(payload) {
-    // comment3
-    order = new Order(payload)
-    // comment 4
-    if(order != null) {
-      par {
-        PurchaseService.createPO(order)
-        InvoiceService.createInvoice(order)
-      }
-    }
-  }
-}`,
-
-  // --- Repro: order-service issue groups ---
-
-  // Group 1: message label dy=-0.5 (backtick comment triggers it)
-  "repro-label-dy": `@Starter(Client)
-// \`POST /orders\`
-A.post(payload) {
-  B.create(payload) {
-    c = new C(payload)
-  }
-}`,
-
-  // Group 2: creation-return arrow geometry (ambiguous return arrows)
-  "repro-creation-return-arrow": `A.method() {
-  b = new B(payload)
-  return b
-}`,
-
-  // Group 3: comment positioning (comments above messages and fragments)
-  "repro-comment-pos": `// comment above message
-A -> B: doWork
-// comment above fragment
-if(cond) {
-  B -> C: inner
-}`,
-
-  // Group 4: fragment body geometry (nested alt+par with comments)
-  "repro-nested-fragment": `A.call() {
-  B.process() {
-    // comment before if
-    if(x) {
-      par {
-        C.task1()
-        D.task2()
-      }
-    }
-  }
-}`,
-
-  // Group 5: icon + stereotype + color + group (with occurrences)
-  "repro-icon-stereo-group": `@EC2 <<BFF>> OrderService #E3FCEF
-group BusinessService {
-  @Lambda PurchaseService
-  @AzureFunction InvoiceService
-}
-OrderService.handle() {
-  PurchaseService.create()
-  InvoiceService.invoice()
-}`,
-
-  // Group 6: par fragment divider (missing in SVG)
-  "repro-par-divider": `A.call() {
-  par {
-    B.task1()
-    C.task2()
-  }
-}`,
-
-  // --- Divider ---
-  "divider": `A -> B: request
-==Phase 2==
-B -> C: forward
-==Done==`,
-
-  // --- Emoji ---
-  "emoji-participant": `[rocket] Production
-Production.deploy()`,
-  "emoji-multi-participants": `[rocket] Production
-[lock] Auth
-[fire] Cache
-Production->Auth: validate
-Auth->Cache: lookup`,
-  "emoji-with-type": `@Database [fire] HotDB
-@Actor [eyes] Reviewer
-Reviewer->HotDB: query`,
-  "emoji-with-stereotype": `<<service>> [lock] Auth
-<<gateway>> [rocket] API
-API->Auth: authenticate`,
-  "emoji-no-emoji-baseline": `Production
-Auth
-Cache
-Production->Auth: validate
-Auth->Cache: lookup`,
-  "emoji-async-message": `A
-B
-A->B: [rocket] launching`,
-  "emoji-alt-condition": `A
-B
-A->B: [check] start
-if(success) {
-  A->B: [rocket] proceed
-}`,
-  "emoji-comment": `A
-B
-// [eyes] review this
-A->B: process`,
-
-  // --- Icons ---
-  "icons": `@Actor User
-@Database DB
-@sqs MQ
-@sns Topic
-
-User.login() {
-  DB.verify()
-  MQ.enqueue()
-  Topic.publish()
-}`,
-
-  // --- Emoji parity cases ---
-  "emoji-sync-call": `[rocket]A.method() {
-  [database]B.query()
-}`,
-  "emoji-nested-calls": `[globe]API.handle() {
-  [lock]Auth.validate() {
-    [database]DB.lookup()
-  }
-}`,
-  "emoji-async-return": `[globe]API->[lock]Auth: validate
-Auth->[database]DB: lookup
-DB-->Auth: [check] found
-Auth-->API: [check] authorized`,
-  "emoji-with-fragment": `[rocket]Client->[lock]Server.request()
-if(authorized) {
-  Server->[database]DB.query()
-  DB-->Server: [check] result
-} else {
-  Server-->Client: [x] denied
-}`,
-  "emoji-divider-case": `[rocket]A->[lock]B.start()
-== [fire] Deploy Phase ==
-B->[database]C.migrate()`,
-  "emoji-group-case": `group Backend {[database]DB [cache]Redis}
-[globe]Gateway->DB.query()
-Gateway->Redis.get()`,
-  "emoji-group-case-2groups": `group Backend {[database]DB [cache]Redis}
-group Frontend {[globe]Gateway}
-Gateway->DB.query()
-Gateway->Redis.get()`,
-  "group-minimal": `group x {a}`,
-  "group-single-participant": `group Frontend {[globe]Gateway}
-group Backend {[database]DB}
-Gateway->DB.query()`,
-  "emoji-comment-styled": `// [eyes] monitoring
-[rocket]A->[lock]B.deploy()
-// [rocket, red] critical path
-B->[database]C.write()`,
-  "emoji-colon-override": `[:red:] Alert
-[rocket] Normal
-Alert->Normal.notify()`,
-  "emoji-icon-combo": `@Actor [star] Admin
-@Database [fire] HotDB
-Admin->HotDB.query()`,
-  "emoji-long-names": `[rocket]ProductionServer->[lock]AuthService.validate()
-AuthService->[database]UserDB.find()
-UserDB-->AuthService: [check] found`,
-  "emoji-simple-async": `[rocket]A->[lock]B: hello
-B-->A: [check] done`,
-  "emoji-self-call": `[gear]Processor.init() {
-  Processor.validate()
-}`,
-  "emoji-title": `title [rocket] Deploy Pipeline
-[lock]A->[database]B.save()`,
-  // emoji variants of existing patterns
-  "emoji-nested-sync-deep": `[rocket]A.methodA() {
-  [lock]B.methodB() {
-    [database]C.methodC() {
-      [fire]D.process()
-    }
-  }
-}`,
-  "emoji-async-many": `[rocket]A [lock]B [database]C
-A->B: [check] msg1
-B->C: [fire] msg2
-C->B: [check] result
-B->A: [check] done`,
-  "emoji-if-else": `[rocket]Client->[lock]Server.request()
-if(valid) {
-  Server->[database]DB.query()
-} else {
-  Server-->Client: [x] denied
-}`,
-  "emoji-tcf": `[globe]A.process() {
-  try {
-    [database]B.save()
-  } catch(e) {
-    [warning]C.handle()
-  } finally {
-    [gear]D.cleanup()
-  }
-}`,
-  "emoji-loop": `[rocket]A->[lock]B.fetch()
-loop(retries < 3) {
-  B->[database]C.query()
-  C-->B: [check] ok
-}`,
-  "emoji-par": `[rocket]Orchestrator.run() {
-  par {
-    [database]DB.write()
-    [cache]Redis.flush()
-  }
-}`,
-  "emoji-return-chain": `[globe]API->[lock]Auth.check() {
-  Auth->[database]DB.query() {
-    DB-->Auth: [check] found
-  }
-  Auth-->API: [check] valid
-}`,
-  "emoji-creation-simple": `[rocket]A.init() {
-  new B()
-}`,
-  "emoji-color": `[rocket] Prod #FF6600
-[lock] Auth #0747A6
-Prod->Auth.validate()`,
-  "emoji-stereotype-only": `<<service>> [lock] Auth
-<<gateway>> [globe] API
-API->Auth.check()`,
-  "emoji-method-name": `A.[rocket]deploy()
-A.[lock]validate()
-A->[database]B.[fire]save()`,
-  "emoji-condition-label": `[rocket]Client->[lock]Server.request()
-if(authorized) {
-  Server->[database]DB.query()
-  DB-->Server: [check] result
-} else {
-  Server-->Client: [x] denied
-}`,
-  "emoji-in-conditions": `if([check] authorized) {
-  A.proceed()
-} else if([warning] rate limited) {
-  A.wait()
-} else {
-  A.deny()
-}`,
-  "emoji-tcf-labels": `A.process() {
-  try {
-    B.save()
-  } catch(DatabaseError) {
-    C.rollback()
-  } finally {
-    D.cleanup()
-  }
-}`,
-  "emoji-loop-condition": `while([rocket] deploying) {
-  A->[database]B.check()
-  B-->A: [check] status
-}`,
-  "emoji-opt-critical": `[rocket]A->[lock]B.request()
-opt {
-  B.[gear]process()
-}
-critical([warning] important) {
-  B->[database]C.save()
-}`,
-  "emoji-nested-mixed": `[globe]Client->[lock]Server.handle() {
-  if([check] cached) {
-    Server->[cache]Redis.[rocket]get()
-  } else {
-    Server->[database]DB.[fire]query() {
-      try {
-        DB.[gear]process()
-      } catch(timeout) {
-        DB-->Server: [warning] retry
-      }
-    }
-  }
-}`,
-  "emoji-all-features": `title [rocket] System Overview
-@Actor [star] Admin
-@Database [fire] DB
-<<service>> [lock] Auth
-[globe] API
-
-// [eyes] authentication flow
-Admin->API.[key]login(credentials)
-API->Auth.[lock]validate(token) {
-  if([check] valid) {
-    Auth->DB.[fire]query(userId)
-    DB-->Auth: [check] found
-  } else {
-    Auth-->API: [x] denied
-  }
-}
-== [rocket] deploy phase ==
-API->[gear]Worker: [rocket] process`,
-  "emoji-chained-calls": `[rocket]A.[lock]auth().[fire]process().[check]save()`,
-  "emoji-assign-return": `[globe]API->[lock]Auth.check() {
-  result = [database]DB.query()
-  return [check] authorized
-}`,
-  "emoji-multi-async": `[rocket]A->[lock]B: [fire] step 1
-B->[database]C: [gear] step 2
-C->[globe]D: [check] step 3
-D-->A: [check] all done`,
-  "emoji-named-params": `[rocket]A.[lock]method(userId=123, name="John")
-[database]B.[fire]create(type="User", active=true)`,
-  "emoji-self-sync": `[gear]selfSync() {
-  [rocket]A.[lock]method() {
-    [database]B.save()
-  }
-}`,
-  "emoji-fragments-return": `[rocket]A.[lock]method() {
-  if([check] x) {
-    return [check] success
-  } else {
-    return [x] failure
-  }
-}`,
-};