From d71d0c2435aa44eb1ef5e08b36497cd9fe9eb9be Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Tue, 27 Feb 2024 14:13:03 +0100
Subject: [PATCH 01/73] WIP - pair programming session w Elias

---
 sandbox/minib.nim  | 45 ++++++++++++++++++++++++++++++++++
 sandbox/minib2.nim | 12 +++++++++
 sandbox/nim.cfg    |  2 ++
 sandbox/notes.md   | 61 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 120 insertions(+)
 create mode 100644 sandbox/minib.nim
 create mode 100644 sandbox/minib2.nim
 create mode 100644 sandbox/nim.cfg
 create mode 100644 sandbox/notes.md

diff --git a/sandbox/minib.nim b/sandbox/minib.nim
new file mode 100644
index 0000000..18d6297
--- /dev/null
+++ b/sandbox/minib.nim
@@ -0,0 +1,45 @@
+# minib (a mini nimib)
+import strformat, macros
+
+macro toStr*(body: untyped): string =
+  (body.toStrLit)
+
+type
+  NbBase* = ref object of RootObj
+    partial*: string
+  NbText* = ref object of NbBase
+    text*: string
+  NbCode* = ref object of NbBase
+    code*: string
+    output*: string
+  NbImage* = ref object of NbBase
+    url*: string
+  NbSummaryDetails* = ref object of NbBase
+    summary*: string
+    details*: seq[NbBase]
+  NbDoc* = object
+    blocks*: seq[NbBase]
+
+template nbInit =
+  var nb {. inject .}: NbDoc
+
+template nbImage(url2: string) =
+  nb.blocks.add NbImage(
+    url: url2,
+    partial: "<img href=\"{{url}}\"><img>"
+  )
+
+# alternative api, similar to python, not used in nimib
+proc image(nb: var NbDoc, url: string) =
+  nb.blocks.add NbImage(url: url)
+
+when isMainModule:
+  import print
+
+  nbInit
+  nbImage: "img1"
+  nb.image("img2")
+
+  print nb
+  print nb.blocks[0].NbImage.url
+  print nb.blocks[1].NbImage.url
\ No newline at end of file
diff --git a/sandbox/minib2.nim b/sandbox/minib2.nim
new file mode 100644
index 0000000..10cca72
--- /dev/null
+++ b/sandbox/minib2.nim
@@ -0,0 +1,12 @@
+import json
+
+type
+  NbBlock* = ref object
+    command*: string
+    blocks*: seq[NbBlock]
+    data*: JsonNode
+  NbCode* = distinct NbBlock
+
+func code(b: NbCode): string =
+  assert "code" in b.NbBlock.data
+  assert b.NbBlock.data["code"].kind == JString
diff --git a/sandbox/nim.cfg b/sandbox/nim.cfg
new file mode 100644
index 0000000..0b88f6e
--- /dev/null
+++ b/sandbox/nim.cfg
@@ -0,0 +1,2 @@
+--hints:off
+--warnings:off
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
new file mode 100644
index 0000000..b162f03
--- /dev/null
+++ b/sandbox/notes.md
@@ -0,0 +1,61 @@
+annoying:
+- just noticed that this PR broke locally my tests: https://github.com/pietroppeter/nimib/pull/211/files
+- I am still using 1.6! not good!
+- still do not have a way to switch easily
+
+plan for today:
+- this is a summary of nimib and refactoring: https://gist.github.com/pietroppeter/0a3699531c8059eea9094e076ac15f9f
+- discuss and see critical points
+- if we manage to code stuff, better
+
+plan:
+- let's start in a sandbox environment from scratch
+- a new NbBlock type
+- goals:
+  - support container blocks
+  - inheritance
+  - user can customize method (how? oop? or I just add a closure?)
+  - support json backend
+  - should work well with multi-language support
+    - might come from json backend
+  - improve locality of block definition
+- current mechanism
+  - does not support container blocks
+  - blocks are defined in two places
+- how to handle the customization of backend?
+  - willing to sacrifice this at the moment
+  - but ideally 
+- not in scope
+  - serialization and deserialization through jsony
+    - Hugo will take care of that
+
+
+
+discussion:
+- **decision**: base block should be a containers block?
+  - yes: you mimic html where every node can have children nodes
+  - (argument for no) if yes all blocks inheriting would need to take into account the children blocks in the templating
+  - example of nbImage: argument for no
+- idea: we could start with locality and start from api and work backwards
+
+
+what kind of blocks do we have:
+- a source block: where I need to capture the source code generating the block
+- a capturing block: where stdout is captured
+- a slim block: with no body
+- a block with body:
+  - body can be executed
+  - body can be discarded
+  - (body can be altered) - no example
+- a container block: that can contain other blocks inside
+- blocks can have side effects: e.g. write to a file, read from a file
+- needs rendering procs (postprocess), could be backend specific
+
+examples:
+- nbCode: source, capturing, withBody(executed), needs postprocess (highlighting)
+- nbText: slim block, needs postprocess (mdToHtml)
+- nbImage: slim block
+- nbSummaryDetails: container block
+
+a new minib:
+- skip capturing
\ No newline at end of file

From 5b698ad1ebfb62cb32750e1b5f1117f0f6bf0e69 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Tue, 27 Feb 2024 17:47:13 +0100
Subject: [PATCH 02/73] review hugoop

---
 sandbox/hugoop/one.nim   | 32 +++++++++++++++++++++++++
 sandbox/hugoop/three.nim | 51 ++++++++++++++++++++++++++++++++++++++++
 sandbox/hugoop/two.nim   | 51 ++++++++++++++++++++++++++++++++++++++++
 sandbox/notes.md         | 39 ++++++++++++++++++++++++++++++
 4 files changed, 173 insertions(+)
 create mode 100644 sandbox/hugoop/one.nim
 create mode 100644 sandbox/hugoop/three.nim
 create mode 100644 sandbox/hugoop/two.nim

diff --git a/sandbox/hugoop/one.nim b/sandbox/hugoop/one.nim
new file mode 100644
index 0000000..2cac4ba
--- /dev/null
+++ b/sandbox/hugoop/one.nim
@@ -0,0 +1,32 @@
+import jsony
+
+type
+  Nimib = ref object of RootObj
+    a, b, c: int
+  NimibChild = ref object of Nimib
+    d, e: float
+
+
+method dump(n: Nimib): string =
+  n[].toJson()
+
+when not defined(noNimibChild): # essential, see below
+  method dump(n: NimibChild): string =
+    n[].toJson()
+
+proc dumpHook*(s: var string, v: Nimib) =
+  s.add v.dump()
+
+let n1: Nimib = Nimib(a: 1, b: 2, c: 3)
+let n2: Nimib = NimibChild(d: 3.14, e: 4.56)
+
+echo n1.toJson()
+echo n2.toJson()
+#[ nim r one
+{"a":1,"b":2,"c":3}
+{"d":3.14,"e":4.56,"a":0,"b":0,"c":0}
+]#
+#[ nim -d:noNimibChild r one
+{"a":1,"b":2,"c":3}
+{"a":0,"b":0,"c":0}
+]#
\ No newline at end of file
diff --git a/sandbox/hugoop/three.nim b/sandbox/hugoop/three.nim
new file mode 100644
index 0000000..003fb55
--- /dev/null
+++ b/sandbox/hugoop/three.nim
@@ -0,0 +1,51 @@
+import jsony, tables
+
+type
+  Nimib = ref object of RootObj
+    a, b, c: int
+    typename: string
+  NimibChild = ref object of Nimib
+    d, e: float
+
+var parseDefs: Table[string, proc (s: string, i: var int): Nimib]
+
+template registerBlock(typename: untyped) =
+  parseDefs[$typename] =
+    proc (s: string, i: var int): Nimib =
+      var v: typename
+      new v
+      parseHook(s, i, v[])
+      result = v
+
+  method dump(n: typename): string =
+    n[].toJson()
+
+proc parseHook*(s: string, i: var int, v: var Nimib) =
+  # First parse the typename
+  var n: Nimib = Nimib()
+  let current_i = i
+  parseHook(s, i, n[])
+  # Reset i
+  i = current_i
+  # Parse the correct type
+  let typename = n.typename
+  v = parseDefs[typename](s, i)
+
+registerBlock(Nimib)
+registerBlock(NimibChild)
+
+# moved this here, I do not need to add dummy dumphook
+proc dumpHook*(s: var string, v: Nimib) =
+  s.add v.dump()
+
+
+let n1: Nimib = Nimib(a: 1, b: 2, c: 3, typename: "Nimib")
+let n2: Nimib = NimibChild(a: 100, d: 3.14, e: 4.56, typename: "NimibChild")
+
+echo n1.toJson()
+echo n2.toJson()
+
+let s1 = n1.toJson().fromJson(Nimib)
+echo s1.toJson()
+let s2 = n2.toJson().fromJson(Nimib)
+echo s2.toJson()
\ No newline at end of file
diff --git a/sandbox/hugoop/two.nim b/sandbox/hugoop/two.nim
new file mode 100644
index 0000000..a976dce
--- /dev/null
+++ b/sandbox/hugoop/two.nim
@@ -0,0 +1,51 @@
+import jsony, tables
+
+type
+  Nimib = ref object of RootObj
+    a, b, c: int
+    typename: string
+  NimibChild = ref object of Nimib
+    d, e: float
+
+method dump(n: Nimib): string =
+  n[].toJson()
+
+method dump(n: NimibChild): string =
+  n[].toJson()
+
+proc dumpHook*(s: var string, v: Nimib) =
+  s.add v.dump()
+
+let n1: Nimib = Nimib(a: 1, b: 2, c: 3, typename: "Nimib")
+let n2: Nimib = NimibChild(a: 100, d: 3.14, e: 4.56, typename: "NimibChild")
+
+echo n1.toJson()
+echo n2.toJson()
+
+proc parseNimib(s: string, i: var int): Nimib =
+  var v = Nimib()
+  parseHook(s, i, v[])
+  result = v
+
+proc parseNimibChild(s: string, i: var int): Nimib =
+  var v = NimibChild()
+  parseHook(s, i, v[])
+  result = v
+
+let parseDefs = {
+  "Nimib": parseNimib,
+  "NimibChild": parseNimibChild
+}.toTable()
+
+proc parseHook*(s: string, i: var int, v: var Nimib) =
+  var n: Nimib = Nimib()
+  let current_i = i
+  parseHook(s, i, n[])
+  i = current_i
+  let typename = n.typename
+  v = parseDefs[typename](s, i)
+
+let s1 = n1.toJson().fromJson(Nimib)
+echo s1.toJson()
+let s2 = n2.toJson().fromJson(Nimib)
+echo s2.toJson()
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
index b162f03..2deaaa4 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,3 +1,42 @@
+## Second day - Feb 28
+
+- [x] review Hugo solution for oop
+- define a scope and make explicit goals and assumptions
+- start working on it, starting from api
+
+### scope
+
+- blocks:
+  - nbBlock
+  - nbCode, nbText, nbImage, nbSummaryDetails
+- commands:
+  - nbInit, nbSave
+- output on save:
+  - a basic html document with water.css
+- support all 3 backends: html, json, md
+- support 2 themes: default, debug (json in html)
+- capture? maybe but no capture blocks inside other capture blocks
+- try to minimize use of external templating system
+  - pluggable templating system?
+
+
+
+
+## Pair programming session - Feb 27
+
+GOALS of TODAY: pair program, get ideas and motivation.
+Achieved.
+
+Main highlights:
+- why I want to do OOP? need to be able to answer that
+- start from API (in particular locality of definition of blocks)
+- define a Scope of what I want to support
+- is this an extension of a templating system?
+
+### details
+
+preparation
+
 annoying:
 - just noticed that this PR broke locally my tests: https://github.com/pietroppeter/nimib/pull/211/files
 - I am still using 1.6! not good!

From b663eb41b5ae533e84555033ed73489ae1b91431 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Tue, 27 Feb 2024 18:05:05 +0100
Subject: [PATCH 03/73] minib3: nbText, nbImage

---
 sandbox/minib3/minib.nim   | 39 ++++++++++++++++++++++++++++++++++++++
 sandbox/minib3/minilib.nim |  0
 sandbox/notes.md           |  9 +++++++++
 3 files changed, 48 insertions(+)
 create mode 100644 sandbox/minib3/minib.nim
 create mode 100644 sandbox/minib3/minilib.nim

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
new file mode 100644
index 0000000..661ca93
--- /dev/null
+++ b/sandbox/minib3/minib.nim
@@ -0,0 +1,39 @@
+# types.nim
+type
+  NbBlock = ref object of RootObj
+  NbText = ref object of NbBlock
+    text: string
+  NbImage = ref object of NbBlock
+    url: string
+  NbDoc = object
+    blk: NbBlock
+    blocks: seq[NbBlock]
+
+# nimib.nim
+template nbInit* =
+  var nb {. inject .}: NbDoc 
+
+template nbText*(ttext: string) =
+  nb.blk = NbText(text: ttext)
+  nb.blocks.add nb.blk
+
+template nbImage*(turl: string) =
+  nb.blk = NbImage(url: turl)
+  nb.blocks.add nb.blk
+
+template nbSave* =
+  discard
+
+when isMainModule:
+  import print
+  # hello.nim
+  nbInit
+  nbText: "hi"
+  nbImage("img.png")
+  nbSave
+
+  print nb
+  print nb.blocks[0]
+  print nb.blocks[0].NbText
+  # print nb.blocks[0].NbImage # correctly fails at runtime
+  print nb.blocks[1].NbImage
diff --git a/sandbox/minib3/minilib.nim b/sandbox/minib3/minilib.nim
new file mode 100644
index 0000000..e69de29
diff --git a/sandbox/notes.md b/sandbox/notes.md
index 2deaaa4..febde85 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -2,6 +2,7 @@
 
 - [x] review Hugo solution for oop
 - define a scope and make explicit goals and assumptions
+- answer why OOP question
 - start working on it, starting from api
 
 ### scope
@@ -19,8 +20,16 @@
 - try to minimize use of external templating system
   - pluggable templating system?
 
+### minib3
 
+implementation of above scope, structure:
+- minib: main library and example
+- minilib: non focus code that comes from existing nimib
 
+todo:
+- [x] structure
+- [x] implement nbText, nbImage
+- [ ] implement nbSave (html backend, default theme, echo to terminal)
 
 ## Pair programming session - Feb 27
 

From d2f243faa04acf06e687d6a60674812c95b731be Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Tue, 27 Feb 2024 21:40:45 +0100
Subject: [PATCH 04/73] minib3: refactor NbDoc as NbBlock and add Nb object

---
 sandbox/minib3/minib.nim | 21 +++++++++++++--------
 sandbox/notes.md         |  6 ++++++
 2 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 661ca93..abb5778 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -1,25 +1,30 @@
 # types.nim
+import tables
+
 type
   NbBlock = ref object of RootObj
   NbText = ref object of NbBlock
     text: string
   NbImage = ref object of NbBlock
     url: string
-  NbDoc = object
-    blk: NbBlock
+  NbDoc = ref object of NbBlock
     blocks: seq[NbBlock]
+  Nb = object
+    blk: NbBlock
+    doc: NbDoc
 
 # nimib.nim
 template nbInit* =
-  var nb {. inject .}: NbDoc 
+  var nb {. inject .}: Nb
+  nb.doc = NbDoc()
 
 template nbText*(ttext: string) =
   nb.blk = NbText(text: ttext)
-  nb.blocks.add nb.blk
+  nb.doc.blocks.add nb.blk
 
 template nbImage*(turl: string) =
   nb.blk = NbImage(url: turl)
-  nb.blocks.add nb.blk
+  nb.doc.blocks.add nb.blk
 
 template nbSave* =
   discard
@@ -33,7 +38,7 @@ when isMainModule:
   nbSave
 
   print nb
-  print nb.blocks[0]
-  print nb.blocks[0].NbText
+  print nb.doc.blocks[0]
+  print nb.doc.blocks[0].NbText
   # print nb.blocks[0].NbImage # correctly fails at runtime
-  print nb.blocks[1].NbImage
+  print nb.doc.blocks[1].NbImage
diff --git a/sandbox/notes.md b/sandbox/notes.md
index febde85..5672dd0 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -30,6 +30,12 @@ todo:
 - [x] structure
 - [x] implement nbText, nbImage
 - [ ] implement nbSave (html backend, default theme, echo to terminal)
+  - [x] refactor NbDoc as NbBlock and add Nb object
+  - [ ] NbRender 
+
+#### key understanding
+
+- I think I want to make NbDoc a NbBlock and basically remove the mustache templating!
 
 ## Pair programming session - Feb 27
 

From d47349effab53e0111d6ce715270f7301ccb4fcd Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Tue, 27 Feb 2024 22:15:10 +0100
Subject: [PATCH 05/73] minib3: wip render (single backend)

---
 sandbox/minib3/minib.nim | 28 +++++++++++++++++++++++++++-
 sandbox/notes.md         |  9 ++++++++-
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index abb5778..1481ac0 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -3,29 +3,54 @@ import tables
 
 type
   NbBlock = ref object of RootObj
+    kind: string
   NbText = ref object of NbBlock
     text: string
   NbImage = ref object of NbBlock
     url: string
   NbDoc = ref object of NbBlock
     blocks: seq[NbBlock]
+  NbRenderFunc = proc (blk: NbBlock): string {. noSideEffect .}
+  NbRender = object
+    funcs: Table[string, NbRenderFunc] 
   Nb = object
-    blk: NbBlock
+    blk: NbBlock # last block processed
     doc: NbDoc
+    backend: NbRender
 
 # nimib.nim
 template nbInit* =
   var nb {. inject .}: Nb
   nb.doc = NbDoc()
+  nb.doc.kind = "NbDoc"
+  nbInitBackend
 
 template nbText*(ttext: string) =
   nb.blk = NbText(text: ttext)
+  nb.blk.kind = "NbText"
   nb.doc.blocks.add nb.blk
 
 template nbImage*(turl: string) =
   nb.blk = NbImage(url: turl)
+  nb.blk.kind = "NbImage"
   nb.doc.blocks.add nb.blk
 
+func nbImageToHtml*(blk: NbBlock): string =
+  let blk = blk.NbImage
+  "<img src= '" & blk.url & "'>"
+
+template addToBackend*(kind: string, f: NbRenderFunc) =
+  nb.backend.funcs[kind] = f
+
+template nbInitBackend* =
+  addToBackend("NbImage", nbImageToHtml) 
+
+func render(nb: Nb, blk: NbBlock): string =
+  if blk.kind in nb.backend.funcs:
+    nb.backend.funcs[blk.kind](blk)
+  else:
+    ""
+
 template nbSave* =
   discard
 
@@ -42,3 +67,4 @@ when isMainModule:
   print nb.doc.blocks[0].NbText
   # print nb.blocks[0].NbImage # correctly fails at runtime
   print nb.doc.blocks[1].NbImage
+  print nb.render nb.doc.blocks[1]
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
index 5672dd0..b55c110 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -31,11 +31,18 @@ todo:
 - [x] implement nbText, nbImage
 - [ ] implement nbSave (html backend, default theme, echo to terminal)
   - [x] refactor NbDoc as NbBlock and add Nb object
-  - [ ] NbRender 
+  - [x] NbRender and NbRenderFunc
+  - [x] single backend (for now)
+  - [x] nb.render blk
+  - [x] nbImageToHtml
+  - [ ] nbTextToHtml
+  - [ ] nbDocToHtml
+
 
 #### key understanding
 
 - I think I want to make NbDoc a NbBlock and basically remove the mustache templating!
+  (could still be reintroduced in a NbLegacyDoc for compatibility reasons)
 
 ## Pair programming session - Feb 27
 

From fd2dc273666758d424acf6a8984915a963094c91 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 28 Feb 2024 11:19:26 +0100
Subject: [PATCH 06/73] minib3: nbTextToHtml

---
 sandbox/minib3/minib.nim | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 1481ac0..95e1d9d 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -19,6 +19,8 @@ type
     backend: NbRender
 
 # nimib.nim
+import markdown
+
 template nbInit* =
   var nb {. inject .}: Nb
   nb.doc = NbDoc()
@@ -39,11 +41,17 @@ func nbImageToHtml*(blk: NbBlock): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
 
+func nbTextToHtml*(blk: NbBlock): string =
+  let blk = blk.NbText
+  {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+    markdown(blk.text, config=initGfmConfig())
+
 template addToBackend*(kind: string, f: NbRenderFunc) =
   nb.backend.funcs[kind] = f
 
 template nbInitBackend* =
-  addToBackend("NbImage", nbImageToHtml) 
+  addToBackend("NbImage", nbImageToHtml)
+  addToBackend("NbText", nbTextToHtml)
 
 func render(nb: Nb, blk: NbBlock): string =
   if blk.kind in nb.backend.funcs:
@@ -58,13 +66,14 @@ when isMainModule:
   import print
   # hello.nim
   nbInit
-  nbText: "hi"
+  nbText: "*hi*"
   nbImage("img.png")
   nbSave
 
   print nb
   print nb.doc.blocks[0]
   print nb.doc.blocks[0].NbText
+  print nb.render nb.doc.blocks[0]
   # print nb.blocks[0].NbImage # correctly fails at runtime
   print nb.doc.blocks[1].NbImage
   print nb.render nb.doc.blocks[1]
\ No newline at end of file

From 48fe2a394a9b621ce591ff7a093fabcba47e6ceb Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 28 Feb 2024 11:42:03 +0100
Subject: [PATCH 07/73] nbDocToHtml and completed nbSave

---
 sandbox/minib3/minib.nim | 27 +++++++++++++++++++++------
 sandbox/notes.md         | 35 +++++++++++++++++++++++++++++++----
 2 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 95e1d9d..76edde2 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -10,7 +10,7 @@ type
     url: string
   NbDoc = ref object of NbBlock
     blocks: seq[NbBlock]
-  NbRenderFunc = proc (blk: NbBlock): string {. noSideEffect .}
+  NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
   NbRender = object
     funcs: Table[string, NbRenderFunc] 
   Nb = object
@@ -20,6 +20,7 @@ type
 
 # nimib.nim
 import markdown
+import std / strutils
 
 template nbInit* =
   var nb {. inject .}: Nb
@@ -37,30 +38,41 @@ template nbImage*(turl: string) =
   nb.blk.kind = "NbImage"
   nb.doc.blocks.add nb.blk
 
-func nbImageToHtml*(blk: NbBlock): string =
+func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
 
-func nbTextToHtml*(blk: NbBlock): string =
+func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbText
   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
     markdown(blk.text, config=initGfmConfig())
 
+# forward declare
+func render(nb: Nb, blk: NbBlock): string
+
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbDoc
+  var blocks: seq[string]
+  for b in blk.blocks:
+    blocks.add nb.render(b)
+  "<!DOCTYPE html>\n<html><head></head>\n<body>\n" & blocks.join("\n") & "\n</body>\n</html>"
+
 template addToBackend*(kind: string, f: NbRenderFunc) =
   nb.backend.funcs[kind] = f
 
 template nbInitBackend* =
   addToBackend("NbImage", nbImageToHtml)
   addToBackend("NbText", nbTextToHtml)
+  addToBackend("NbDoc", nbDocToHtml)
 
 func render(nb: Nb, blk: NbBlock): string =
   if blk.kind in nb.backend.funcs:
-    nb.backend.funcs[blk.kind](blk)
+    nb.backend.funcs[blk.kind](blk, nb)
   else:
     ""
 
 template nbSave* =
-  discard
+  echo nb.render nb.doc
 
 when isMainModule:
   import print
@@ -76,4 +88,7 @@ when isMainModule:
   print nb.render nb.doc.blocks[0]
   # print nb.blocks[0].NbImage # correctly fails at runtime
   print nb.doc.blocks[1].NbImage
-  print nb.render nb.doc.blocks[1]
\ No newline at end of file
+  print nb.render nb.doc.blocks[1]
+
+  print nb.render nb.doc
+  
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
index b55c110..ba51e65 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,7 +1,20 @@
+## Naming
+
+- not sure I still like the name backend for the rendering engine
+  that changes from blocks to string (and could be a themed html, a json, markdown...)
+
+### notes on backends
+
+- I could implement specific behaviours:
+  - markdown backend defaults to html backend when not defined
+  - html backend could default to a commented json output when not defined
+  - json backend should always be defined
+    - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
+
 ## Second day - Feb 28
 
 - [x] review Hugo solution for oop
-- define a scope and make explicit goals and assumptions
+- [x] define a scope and make explicit goals and assumptions
 - answer why OOP question
 - start working on it, starting from api
 
@@ -29,14 +42,28 @@ implementation of above scope, structure:
 todo:
 - [x] structure
 - [x] implement nbText, nbImage
-- [ ] implement nbSave (html backend, default theme, echo to terminal)
+- [x] implement nbSave (html backend, default theme, echo to terminal)
   - [x] refactor NbDoc as NbBlock and add Nb object
   - [x] NbRender and NbRenderFunc
   - [x] single backend (for now)
   - [x] nb.render blk
   - [x] nbImageToHtml
-  - [ ] nbTextToHtml
-  - [ ] nbDocToHtml
+  - [x] nbTextToHtml
+  - [x] nbDocToHtml
+- [ ] implement json backend
+- later:
+  - md backend
+  - nbCode, nbSummaryDetails
+  - sugar for block creation
+  - ...
+
+decisions:
+- 1) what do I pass to the render function?
+  - docs and any container block will need the full backend
+  - currently passing the whole Nb object but it might be an overkill
+- 2) where is the default backend defined?
+  - currently in Nb object (same as before)
+
 
 
 #### key understanding

From 0932cdb7bf1bf85959db62f8c367bae686ba99be Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Thu, 29 Feb 2024 17:19:12 +0100
Subject: [PATCH 08/73] more understanding on how this should look (less
 progress on code)

---
 sandbox/minib3/minib.nim | 89 ++++++++++++++++++++++++----------------
 sandbox/notes.md         | 17 +++++++-
 2 files changed, 69 insertions(+), 37 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 76edde2..8842fa6 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -4,23 +4,36 @@ import tables
 type
   NbBlock = ref object of RootObj
     kind: string
-  NbText = ref object of NbBlock
-    text: string
-  NbImage = ref object of NbBlock
-    url: string
-  NbDoc = ref object of NbBlock
-    blocks: seq[NbBlock]
   NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
   NbRender = object
     funcs: Table[string, NbRenderFunc] 
+  NbDoc = ref object of NbBlock
+    blocks: seq[NbBlock]
   Nb = object
     blk: NbBlock # last block processed
-    doc: NbDoc
+    doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
     backend: NbRender
 
+# this needs to be know for all container blocks
+func render(nb: Nb, blk: NbBlock): string =
+  if blk.kind in nb.backend.funcs:
+    nb.backend.funcs[blk.kind](blk, nb)
+  else:
+    ""
+
+# themes.nim
+import std / strutils
+
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbDoc
+  var blocks: seq[string]
+  for b in blk.blocks:
+    blocks.add nb.render(b)
+  "<!DOCTYPE html>\n<html><head></head>\n<body>\n" & blocks.join("\n") & "\n</body>\n</html>"
+
+
 # nimib.nim
 import markdown
-import std / strutils
 
 template nbInit* =
   var nb {. inject .}: Nb
@@ -28,34 +41,48 @@ template nbInit* =
   nb.doc.kind = "NbDoc"
   nbInitBackend
 
+template nbSave* =
+  echo nb.render nb.doc
+
+# all other blocks are in a sense all custom blocks
+# we could add sugar for common block creation
+type
+  NbText = ref object of NbBlock
+    text: string
 template nbText*(ttext: string) =
-  nb.blk = NbText(text: ttext)
-  nb.blk.kind = "NbText"
+  nb.blk = NbText(text: ttext, kind: "NbText")
   nb.doc.blocks.add nb.blk
+func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbText
+  {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+    markdown(blk.text, config=initGfmConfig())
+#[ the above could be shortened with sugar to:
+newNbBlock(nbText):
+  text: string
+  toHtml:
+    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+      markdown(blk.text, config=initGfmConfig())
+]#
 
+
+
+type
+  NbImage = ref object of NbBlock
+    url: string
 template nbImage*(turl: string) =
-  nb.blk = NbImage(url: turl)
-  nb.blk.kind = "NbImage"
+  nb.blk = NbImage(url: turl, kind: "NbImage")
   nb.doc.blocks.add nb.blk
-
 func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
+#[ the above could be shortened with sugar to:
+newNbBlock(nbImage):
+  url: string
+  toHtml:
+    "<img src= '" & blk.url & "'>"
+]#
 
-func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbText
-  {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-    markdown(blk.text, config=initGfmConfig())
-
-# forward declare
-func render(nb: Nb, blk: NbBlock): string
 
-func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbDoc
-  var blocks: seq[string]
-  for b in blk.blocks:
-    blocks.add nb.render(b)
-  "<!DOCTYPE html>\n<html><head></head>\n<body>\n" & blocks.join("\n") & "\n</body>\n</html>"
 
 template addToBackend*(kind: string, f: NbRenderFunc) =
   nb.backend.funcs[kind] = f
@@ -65,15 +92,6 @@ template nbInitBackend* =
   addToBackend("NbText", nbTextToHtml)
   addToBackend("NbDoc", nbDocToHtml)
 
-func render(nb: Nb, blk: NbBlock): string =
-  if blk.kind in nb.backend.funcs:
-    nb.backend.funcs[blk.kind](blk, nb)
-  else:
-    ""
-
-template nbSave* =
-  echo nb.render nb.doc
-
 when isMainModule:
   import print
   # hello.nim
@@ -91,4 +109,3 @@ when isMainModule:
   print nb.render nb.doc.blocks[1]
 
   print nb.render nb.doc
-  
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
index ba51e65..e6e895b 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -11,6 +11,22 @@
   - json backend should always be defined
     - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
 
+## Third day - Feb 29
+
+- goal: add json backend
+- useful distraction: added a potential idea for sugar for creating blocks
+- interesting question: now NbDoc is special, what if I make it non special?
+- an idea I am realizing:
+  - all side effects should happen during block creation
+  - block rendering should be kept pure
+  - in particular this means that block that need an id from global nb object need to generate it at block creation time!
+- reminder for later: to fully support custom container blocks I will need to add in
+  Nb object something that tells me where to add next block
+
+todo:
+- [x] restructured minib and added sugar for blocks
+- [ ] json backend
+
 ## Second day - Feb 28
 
 - [x] review Hugo solution for oop
@@ -65,7 +81,6 @@ decisions:
   - currently in Nb object (same as before)
 
 
-
 #### key understanding
 
 - I think I want to make NbDoc a NbBlock and basically remove the mustache templating!

From 2ad8153eee39cd929640fdb215fb3c53c0d20580 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Thu, 29 Feb 2024 18:19:05 +0100
Subject: [PATCH 09/73] json backend now works!

---
 sandbox/minib3/minib.nim   | 95 +++++++++++++++++++++++++++-----------
 sandbox/minib3/minilib.nim |  0
 sandbox/notes.md           |  3 +-
 3 files changed, 70 insertions(+), 28 deletions(-)
 delete mode 100644 sandbox/minib3/minilib.nim

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 8842fa6..e821a0f 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -14,13 +14,49 @@ type
     doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
     backend: NbRender
 
-# this needs to be know for all container blocks
+# this needs to be know for all container blocks not sure whether to put it in types
 func render(nb: Nb, blk: NbBlock): string =
   if blk.kind in nb.backend.funcs:
     nb.backend.funcs[blk.kind](blk, nb)
   else:
     ""
 
+# globals.nim
+var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
+var nbToHtml: NbRender # since we need it for json, let's make it also for html
+
+# jsons.nim
+import jsony
+
+template addNbBlockToJson*(kind: untyped) =
+  nbToJson[$kind] =
+    proc (s: string, i: var int): NbBlock =
+      var v: kind
+      new v
+      parseHook(s, i, v[])
+      result = v
+
+  method dump(n: kind): string =
+    n[].toJson()
+
+proc parseHook*(s: string, i: var int, v: var NbBlock) =
+  # First parse the typename
+  var n: NbBlock = NbBlock()
+  let current_i = i
+  parseHook(s, i, n[])
+  # Reset i
+  i = current_i
+  # Parse the correct type
+  let kind = n.kind
+  v = nbToJson[kind](s, i)
+
+method dump(n: NbBlock): string =
+    n[].toJson()
+
+proc dumpHook*(s: var string, v: NbBlock) =
+  s.add v.dump()
+
+
 # themes.nim
 import std / strutils
 
@@ -30,16 +66,16 @@ func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   for b in blk.blocks:
     blocks.add nb.render(b)
   "<!DOCTYPE html>\n<html><head></head>\n<body>\n" & blocks.join("\n") & "\n</body>\n</html>"
-
+addNbBlockToJson(NbDoc)
 
 # nimib.nim
 import markdown
 
 template nbInit* =
   var nb {. inject .}: Nb
-  nb.doc = NbDoc()
-  nb.doc.kind = "NbDoc"
-  nbInitBackend
+  nb.doc = NbDoc(kind: "NbDoc")
+  nbToHtml.funcs["NbDoc"] = nbDocToHtml
+  nb.backend = nbToHtml
 
 template nbSave* =
   echo nb.render nb.doc
@@ -56,6 +92,8 @@ func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbText
   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
     markdown(blk.text, config=initGfmConfig())
+nbToHtml.funcs["NbText"] = nbTextToHtml
+addNbBlockToJson(NbText)
 #[ the above could be shortened with sugar to:
 newNbBlock(nbText):
   text: string
@@ -65,7 +103,6 @@ newNbBlock(nbText):
 ]#
 
 
-
 type
   NbImage = ref object of NbBlock
     url: string
@@ -75,6 +112,8 @@ template nbImage*(turl: string) =
 func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
+nbToHtml.funcs["NbImage"] = nbImageToHtml
+addNbBlockToJson(NbImage)
 #[ the above could be shortened with sugar to:
 newNbBlock(nbImage):
   url: string
@@ -82,30 +121,32 @@ newNbBlock(nbImage):
     "<img src= '" & blk.url & "'>"
 ]#
 
-
-
-template addToBackend*(kind: string, f: NbRenderFunc) =
-  nb.backend.funcs[kind] = f
-
-template nbInitBackend* =
-  addToBackend("NbImage", nbImageToHtml)
-  addToBackend("NbText", nbTextToHtml)
-  addToBackend("NbDoc", nbDocToHtml)
-
 when isMainModule:
   import print
-  # hello.nim
   nbInit
   nbText: "*hi*"
   nbImage("img.png")
   nbSave
-
-  print nb
-  print nb.doc.blocks[0]
-  print nb.doc.blocks[0].NbText
-  print nb.render nb.doc.blocks[0]
-  # print nb.blocks[0].NbImage # correctly fails at runtime
-  print nb.doc.blocks[1].NbImage
-  print nb.render nb.doc.blocks[1]
-
-  print nb.render nb.doc
+  #[
+<!DOCTYPE html>
+<html><head></head>
+<body>
+<p><em>hi</em></p>
+
+<img src= 'img.png'>
+</body>
+</html>
+  ]#
+
+  let docToJson = nb.doc.toJson()
+  let docFromJson = docToJson.fromJson(NbDoc)
+  print docToJson
+  print docFromJson
+  print docFromJson.blocks[0].NbText
+  print docFromJson.blocks[1].NbImage
+  #[
+  docToJson="{"blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"}],"kind":"NbDoc"}"
+  docFromJson=NbDoc:ObjectType(blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage")], kind: "NbDoc")
+  docFromJson.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
+  docFromJson.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage") 
+  ]#
diff --git a/sandbox/minib3/minilib.nim b/sandbox/minib3/minilib.nim
deleted file mode 100644
index e69de29..0000000
diff --git a/sandbox/notes.md b/sandbox/notes.md
index e6e895b..e9aca67 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -22,10 +22,11 @@
   - in particular this means that block that need an id from global nb object need to generate it at block creation time!
 - reminder for later: to fully support custom container blocks I will need to add in
   Nb object something that tells me where to add next block
+- removed minilib, not useful since I would need import and that's a different problem
 
 todo:
 - [x] restructured minib and added sugar for blocks
-- [ ] json backend
+- [x] json backend (hugo's work is great!)
 
 ## Second day - Feb 28
 

From a52dbe66c8440578732f98ab2b2b88d2791de6fd Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Sat, 2 Mar 2024 10:35:16 +0100
Subject: [PATCH 10/73] notes from fourth day

---
 sandbox/notes.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/sandbox/notes.md b/sandbox/notes.md
index e9aca67..627d719 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -11,6 +11,19 @@
   - json backend should always be defined
     - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
 
+## Notes from Fourth day - Match 1st
+
+Some notes for me for later while I am on mobile related to NbRender type:
+- right now NbDoc forced me to change the signature to add also Nb object
+- I think I should change to pass only NbDoc object (type of the root object)
+- also I could have NbRender support two types of functions (one for NbDoc like blocks one for NbText like blocks)
+- I should encode the block type in the base block
+- the general idea is to make the internal api safer (allow only what needs to be allowed)
+- also the idea is to have the NbDoc the unit of serialization and rendering should not access anything outside of that (it will not be accessible from a deserialized version)
+- and in NbDoc the plan is to have a theme field that is skipped on json serialization
+- there is a tension between what you want to be able to serialize (content and specificities of a page) and what you want to be controlled (later) by the SSG (like the theme) and should not be serialized (also because it is redundant). Tension also with a third element which is the fact that rendering does need a theme
+- as another, unrelated note, minimal theme could contain only doctype html and title element (see https://unplannedobsolescence.com/blog/best-hello-world-web-development/)
+
 ## Third day - Feb 29
 
 - goal: add json backend
@@ -87,7 +100,7 @@ decisions:
 - I think I want to make NbDoc a NbBlock and basically remove the mustache templating!
   (could still be reintroduced in a NbLegacyDoc for compatibility reasons)
 
-## Pair programming session - Feb 27
+## Pair programming session - Feb 26
 
 GOALS of TODAY: pair program, get ideas and motivation.
 Achieved.

From ffb4bd98ad5b06db6d816ec6b54c244916c94580 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Sat, 2 Mar 2024 10:46:38 +0100
Subject: [PATCH 11/73] notes from fifth day

---
 sandbox/notes.md | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/sandbox/notes.md b/sandbox/notes.md
index 627d719..b6c471d 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -11,6 +11,35 @@
   - json backend should always be defined
     - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
 
+## Fifth day - Martch 2nd
+
+what could I work on:
+- on theme
+  - use the minimal theme
+  - use a theme field that is skipped dring json generation
+- on container blocks
+  - implement summary details
+  - implement a flexbox container!
+    - that and a generic styled span container could allow me to easily create a grid...
+- for later
+  - md backend (and revision of backends)
+  - nbCode
+  - nbJs stuff
+
+more thoughts:
+- can I also use a super method or something to wrap the rendered block in a NbBlock?
+  - for example it could be used to add a class name inside a div
+    - this could be important for example to customize code block appearance
+  - or to add an optional id to a block
+  - (this could anyway be added later)
+  - and it could be added as something that by default a block does during rendering
+  - it might have a different signature (takes rendering of content and outputs new rendering)
+- restriction/variation of render method should be done towards the end,
+  so that I know what multiple blocks should be able to 
+- instead of passing Nb object to render method I could pass a pointer to the current render backend
+  - one could use this to do fun stuff, for example have a container block that chnages the rendering engine, I could show the output of json backend inside a html backend as raw json and so on
+  - oooh coool!
+
 ## Notes from Fourth day - Match 1st
 
 Some notes for me for later while I am on mobile related to NbRender type:
@@ -80,7 +109,7 @@ todo:
   - [x] nbImageToHtml
   - [x] nbTextToHtml
   - [x] nbDocToHtml
-- [ ] implement json backend
+- [x] implement json backend
 - later:
   - md backend
   - nbCode, nbSummaryDetails

From 5e6727e0b9cca78795e3bfe1b2865dd1115fc38a Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Sat, 2 Mar 2024 10:55:56 +0100
Subject: [PATCH 12/73] [skip ci] fix type and test skip ci message

---
 sandbox/notes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sandbox/notes.md b/sandbox/notes.md
index b6c471d..2acae11 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -11,7 +11,7 @@
   - json backend should always be defined
     - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
 
-## Fifth day - Martch 2nd
+## Fifth day - March 2nd
 
 what could I work on:
 - on theme

From c35114e462e20d13518b5688e3bc83b5d56ead0b Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Mon, 25 Mar 2024 13:48:26 +0100
Subject: [PATCH 13/73] add NbContainer

---
 sandbox/minib3/minib.nim | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index e821a0f..9f5d878 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -6,13 +6,17 @@ type
     kind: string
   NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
   NbRender = object
-    funcs: Table[string, NbRenderFunc] 
-  NbDoc = ref object of NbBlock
+    funcs: Table[string, NbRenderFunc]
+  NbContainer = ref object of NbBlock
     blocks: seq[NbBlock]
+    parent: NbContainer
+  NbDoc = ref object of NbContainer
+    title: string
   Nb = object
     blk: NbBlock # last block processed
     doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
-    backend: NbRender
+    container: NbContainer # current container
+    backend: NbRender # current backend
 
 # this needs to be know for all container blocks not sure whether to put it in types
 func render(nb: Nb, blk: NbBlock): string =
@@ -74,6 +78,7 @@ import markdown
 template nbInit* =
   var nb {. inject .}: Nb
   nb.doc = NbDoc(kind: "NbDoc")
+  nb.container = nb.doc
   nbToHtml.funcs["NbDoc"] = nbDocToHtml
   nb.backend = nbToHtml
 
@@ -87,7 +92,7 @@ type
     text: string
 template nbText*(ttext: string) =
   nb.blk = NbText(text: ttext, kind: "NbText")
-  nb.doc.blocks.add nb.blk
+  nb.container.blocks.add nb.blk
 func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbText
   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
@@ -108,7 +113,7 @@ type
     url: string
 template nbImage*(turl: string) =
   nb.blk = NbImage(url: turl, kind: "NbImage")
-  nb.doc.blocks.add nb.blk
+  nb.container.blocks.add nb.blk
 func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"

From 954ef22413b005fdca26e652033847e87488819e Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Mon, 25 Mar 2024 14:00:54 +0100
Subject: [PATCH 14/73] change minimal theme and add NbContainerToHtml

---
 sandbox/minib3/minib.nim | 38 +++++++++++++++++++++++++++++++-------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 9f5d878..4b60241 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -64,12 +64,17 @@ proc dumpHook*(s: var string, v: NbBlock) =
 # themes.nim
 import std / strutils
 
-func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbDoc
-  var blocks: seq[string]
+func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbContainer
   for b in blk.blocks:
-    blocks.add nb.render(b)
-  "<!DOCTYPE html>\n<html><head></head>\n<body>\n" & blocks.join("\n") & "\n</body>\n</html>"
+    result.add nb.render(b).strip & '\n'
+  result.strip
+
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  "<!DOCTYPE html>\n" &
+  "<title>" & blk.NbDoc.title & "<title>\n" &
+  nbContainerToHtml(blk, nb)
+  
 addNbBlockToJson(NbDoc)
 
 # nimib.nim
@@ -77,7 +82,7 @@ import markdown
 
 template nbInit* =
   var nb {. inject .}: Nb
-  nb.doc = NbDoc(kind: "NbDoc")
+  nb.doc = NbDoc(kind: "NbDoc", title: "a nimib document")
   nb.container = nb.doc
   nbToHtml.funcs["NbDoc"] = nbDocToHtml
   nb.backend = nbToHtml
@@ -107,7 +112,6 @@ newNbBlock(nbText):
       markdown(blk.text, config=initGfmConfig())
 ]#
 
-
 type
   NbImage = ref object of NbBlock
     url: string
@@ -126,6 +130,26 @@ newNbBlock(nbImage):
     "<img src= '" & blk.url & "'>"
 ]#
 
+type
+  NbDetails = ref object of NbContainer
+    summary: string
+template nbDetails*(tsummary: string, body: untyped) =
+  let blk = NbDetails(summary: tsummary, kind: "NbDetails")
+  blk.parent = nb.container # save current container
+  nb.blk = blk
+  nb.container.blocks.add nb.blk
+  
+  nb.container = blk
+  body
+  nb.container = blk.parent
+
+func NbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbDetails
+  
+nbToHtml.funcs["NbDetails"] = NbDetailsToHtml
+addNbBlockToJson(NbDetails)
+
+
 when isMainModule:
   import print
   nbInit

From 5d995ac6df4946de244110dcd5d7975b31e7537f Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 27 Mar 2024 11:55:35 +0100
Subject: [PATCH 15/73] even a specific dumpHoook does not work!

---
 sandbox/minib3/minib.nim | 135 +++++++++++++++++++++++++++++++++++++--
 sandbox/notes.md         |   6 ++
 2 files changed, 135 insertions(+), 6 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index 4b60241..e00a640 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -54,12 +54,89 @@ proc parseHook*(s: string, i: var int, v: var NbBlock) =
   let kind = n.kind
   v = nbToJson[kind](s, i)
 
+# I think these two skipHooks do NOT work since they refer
+# to a ref object while jsony will dump the nonref object (for which I have no name!)
+proc skipHook*(T: typedesc[NbContainer], key: static string): bool =
+  key in ["parent"]
+
+proc skipHook*(T: typedesc[NbDoc], key: static string): bool =
+  key in ["parent"]
+
 method dump(n: NbBlock): string =
     n[].toJson()
 
 proc dumpHook*(s: var string, v: NbBlock) =
   s.add v.dump()
 
+template dumpKey(s: var string, v: string) =
+  const v2 = v.toJson() & ":"
+  s.add v2
+
+
+proc dumpHook*(s: var string, v: NbContainer) =
+  s.add '{'
+  var i = 0
+  when compiles(for k, e in v.pairs: discard):
+    # Tables and table like objects.
+    for k, e in v.pairs:
+      if i > 0:
+        s.add ','
+      s.dumpHook(k)
+      s.add ':'
+      s.dumpHook(e)
+      inc i
+  else:
+    # Normal objects.
+    for k, e in v[].fieldPairs:
+      when compiles(skipHook(type(v), k)):
+        when skipHook(type(v), k):
+          discard
+        else:
+          if i > 0:
+            s.add ','
+          s.dumpKey(k)
+          s.dumpHook(e)
+          inc i
+      else:
+        if i > 0:
+          s.add ','
+        s.dumpKey(k)
+        s.dumpHook(e)
+        inc i
+  s.add '}'
+
+proc dumpHook*(s: var string, v: NbDoc) =
+  s.add '{'
+  var i = 0
+  when compiles(for k, e in v.pairs: discard):
+    # Tables and table like objects.
+    for k, e in v.pairs:
+      if i > 0:
+        s.add ','
+      s.dumpHook(k)
+      s.add ':'
+      s.dumpHook(e)
+      inc i
+  else:
+    # Normal objects.
+    for k, e in v[].fieldPairs:
+      when compiles(skipHook(type(v), k)):
+        when skipHook(type(v), k):
+          discard
+        else:
+          if i > 0:
+            s.add ','
+          s.dumpKey(k)
+          s.dumpHook(e)
+          inc i
+      else:
+        if i > 0:
+          s.add ','
+        s.dumpKey(k)
+        s.dumpHook(e)
+        inc i
+  s.add '}'
+
 
 # themes.nim
 import std / strutils
@@ -69,6 +146,7 @@ func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
   for b in blk.blocks:
     result.add nb.render(b).strip & '\n'
   result.strip
+# should I add this to the global object?
 
 func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   "<!DOCTYPE html>\n" &
@@ -145,16 +223,51 @@ template nbDetails*(tsummary: string, body: untyped) =
 
 func NbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbDetails
+  "<details><summary>" & blk.summary & "</summary>\n" &
+  nbContainerToHtml(blk, nb) &
+  "\n</details>"
   
 nbToHtml.funcs["NbDetails"] = NbDetailsToHtml
 addNbBlockToJson(NbDetails)
+proc dumpHook*(s: var string, v: NbDetails) =
+  s.add '{'
+  var i = 0
+  when compiles(for k, e in v.pairs: discard):
+    # Tables and table like objects.
+    for k, e in v.pairs:
+      if i > 0:
+        s.add ','
+      s.dumpHook(k)
+      s.add ':'
+      s.dumpHook(e)
+      inc i
+  else:
+    # Normal objects.
+    for k, e in v[].fieldPairs:
+      when compiles(skipHook(type(v), k)):
+        when skipHook(type(v), k):
+          discard
+        else:
+          if i > 0:
+            s.add ','
+          s.dumpKey(k)
+          s.dumpHook(e)
+          inc i
+      else:
+        if i > 0:
+          s.add ','
+        s.dumpKey(k)
+        s.dumpHook(e)
+        inc i
+  s.add '}'
 
 
 when isMainModule:
   import print
   nbInit
-  nbText: "*hi*"
-  nbImage("img.png")
+  nbDetails("Click for details:"):
+    nbText: "*hi*"
+    nbImage("img.png")
   nbSave
   #[
 <!DOCTYPE html>
@@ -167,12 +280,22 @@ when isMainModule:
 </html>
   ]#
 
-  let docToJson = nb.doc.toJson()
-  let docFromJson = docToJson.fromJson(NbDoc)
+  let docToJson = nb.doc.blocks[0].NbDetails.blocks.toJson()
+  print nb.doc.blocks[0].NbDetails
+  echo docToJson
+  print nb.doc.blocks[0].NbDetails.toJson() # fails because of too much recursion
+  # does not fail anymore if I add the specific dumpHook
+  let docFromJson = docToJson.fromJson(seq[NbBlock]) # but now this fails
+  print docFromJson
+  #[
   print docToJson
   print docFromJson
-  print docFromJson.blocks[0].NbText
-  print docFromJson.blocks[1].NbImage
+  print docFromJson.blocks[0].NbDetails
+  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
+  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
+
+  ]#
+
   #[
   docToJson="{"blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"}],"kind":"NbDoc"}"
   docFromJson=NbDoc:ObjectType(blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage")], kind: "NbDoc")
diff --git a/sandbox/notes.md b/sandbox/notes.md
index 2acae11..95da46a 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,3 +1,9 @@
+## getting back working on this
+
+- added NbContainer type, refactored NbDoc added NbDetails as example
+- FAILURE: serialization to json has issues!
+
+---
 ## Naming
 
 - not sure I still like the name backend for the rendering engine

From 5d761c324c13a82c46a0f60ad33233d56193ce2a Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 27 Mar 2024 16:57:23 +0100
Subject: [PATCH 16/73] new NbContainer implementation, add api `nb.add` and
 `nb.withContainer(container) : body`

---
 sandbox/minib3/minib.nim | 115 +++++++++------------------------------
 sandbox/notes.md         |   6 +-
 2 files changed, 30 insertions(+), 91 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index e00a640..c634912 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -9,13 +9,12 @@ type
     funcs: Table[string, NbRenderFunc]
   NbContainer = ref object of NbBlock
     blocks: seq[NbBlock]
-    parent: NbContainer
   NbDoc = ref object of NbContainer
     title: string
   Nb = object
     blk: NbBlock # last block processed
     doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
-    container: NbContainer # current container
+    containers: seq[NbContainer] # current container
     backend: NbRender # current backend
 
 # this needs to be know for all container blocks not sure whether to put it in types
@@ -54,14 +53,6 @@ proc parseHook*(s: string, i: var int, v: var NbBlock) =
   let kind = n.kind
   v = nbToJson[kind](s, i)
 
-# I think these two skipHooks do NOT work since they refer
-# to a ref object while jsony will dump the nonref object (for which I have no name!)
-proc skipHook*(T: typedesc[NbContainer], key: static string): bool =
-  key in ["parent"]
-
-proc skipHook*(T: typedesc[NbDoc], key: static string): bool =
-  key in ["parent"]
-
 method dump(n: NbBlock): string =
     n[].toJson()
 
@@ -73,71 +64,6 @@ template dumpKey(s: var string, v: string) =
   s.add v2
 
 
-proc dumpHook*(s: var string, v: NbContainer) =
-  s.add '{'
-  var i = 0
-  when compiles(for k, e in v.pairs: discard):
-    # Tables and table like objects.
-    for k, e in v.pairs:
-      if i > 0:
-        s.add ','
-      s.dumpHook(k)
-      s.add ':'
-      s.dumpHook(e)
-      inc i
-  else:
-    # Normal objects.
-    for k, e in v[].fieldPairs:
-      when compiles(skipHook(type(v), k)):
-        when skipHook(type(v), k):
-          discard
-        else:
-          if i > 0:
-            s.add ','
-          s.dumpKey(k)
-          s.dumpHook(e)
-          inc i
-      else:
-        if i > 0:
-          s.add ','
-        s.dumpKey(k)
-        s.dumpHook(e)
-        inc i
-  s.add '}'
-
-proc dumpHook*(s: var string, v: NbDoc) =
-  s.add '{'
-  var i = 0
-  when compiles(for k, e in v.pairs: discard):
-    # Tables and table like objects.
-    for k, e in v.pairs:
-      if i > 0:
-        s.add ','
-      s.dumpHook(k)
-      s.add ':'
-      s.dumpHook(e)
-      inc i
-  else:
-    # Normal objects.
-    for k, e in v[].fieldPairs:
-      when compiles(skipHook(type(v), k)):
-        when skipHook(type(v), k):
-          discard
-        else:
-          if i > 0:
-            s.add ','
-          s.dumpKey(k)
-          s.dumpHook(e)
-          inc i
-      else:
-        if i > 0:
-          s.add ','
-        s.dumpKey(k)
-        s.dumpHook(e)
-        inc i
-  s.add '}'
-
-
 # themes.nim
 import std / strutils
 
@@ -155,13 +81,26 @@ func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   
 addNbBlockToJson(NbDoc)
 
+# blocks.nim
+# should I add nb.blk.add blk to both add and with Container
+proc add(nb: var Nb, blk: NbBlock) =
+  if nb.containers.len == 0:
+    nb.doc.blocks.add blk
+  else:
+    nb.containers[^1].blocks.add blk
+
+template withContainer(nb: var Nb, container: NbContainer, body: untyped) =
+  nb.add container
+  nb.containers.add container
+  body
+  discard nb.containers.pop
+
 # nimib.nim
 import markdown
 
 template nbInit* =
   var nb {. inject .}: Nb
   nb.doc = NbDoc(kind: "NbDoc", title: "a nimib document")
-  nb.container = nb.doc
   nbToHtml.funcs["NbDoc"] = nbDocToHtml
   nb.backend = nbToHtml
 
@@ -175,7 +114,7 @@ type
     text: string
 template nbText*(ttext: string) =
   nb.blk = NbText(text: ttext, kind: "NbText")
-  nb.container.blocks.add nb.blk
+  nb.add nb.blk
 func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbText
   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
@@ -195,7 +134,7 @@ type
     url: string
 template nbImage*(turl: string) =
   nb.blk = NbImage(url: turl, kind: "NbImage")
-  nb.container.blocks.add nb.blk
+  nb.add nb.blk
 func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
@@ -213,13 +152,9 @@ type
     summary: string
 template nbDetails*(tsummary: string, body: untyped) =
   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
-  blk.parent = nb.container # save current container
   nb.blk = blk
-  nb.container.blocks.add nb.blk
-  
-  nb.container = blk
-  body
-  nb.container = blk.parent
+  nb.withContainer(blk):
+    body
 
 func NbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbDetails
@@ -280,13 +215,13 @@ when isMainModule:
 </html>
   ]#
 
-  let docToJson = nb.doc.blocks[0].NbDetails.blocks.toJson()
-  print nb.doc.blocks[0].NbDetails
-  echo docToJson
-  print nb.doc.blocks[0].NbDetails.toJson() # fails because of too much recursion
-  # does not fail anymore if I add the specific dumpHook
-  let docFromJson = docToJson.fromJson(seq[NbBlock]) # but now this fails
+  let docToJson = nb.doc.toJson()
+  print docToJson
+  let docFromJson = docToJson.fromJson(NbDoc) # but now this fails
   print docFromJson
+  print docFromJson.blocks[0].NbDetails
+  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
+  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
   #[
   print docToJson
   print docFromJson
diff --git a/sandbox/notes.md b/sandbox/notes.md
index 95da46a..f22f5c0 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,8 +1,12 @@
 ## getting back working on this
 
+### containers
 - added NbContainer type, refactored NbDoc added NbDetails as example
 - FAILURE: serialization to json has issues!
-
+- alternative implementation of containers that does not use circular references
+  (simpler, no issues)
+  - add api a `nb.add` and `nb.withContainer(container)
+: body`
 ---
 ## Naming
 

From 80cd2c50a2c35b386f68278a67efae5ebd5afd76 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 27 Mar 2024 17:03:31 +0100
Subject: [PATCH 17/73] hide nb.blk api in add

---
 sandbox/minib3/minib.nim | 44 +++++++---------------------------------
 sandbox/notes.md         |  3 ++-
 2 files changed, 9 insertions(+), 38 deletions(-)

diff --git a/sandbox/minib3/minib.nim b/sandbox/minib3/minib.nim
index c634912..166fde8 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib3/minib.nim
@@ -82,8 +82,8 @@ func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
 addNbBlockToJson(NbDoc)
 
 # blocks.nim
-# should I add nb.blk.add blk to both add and with Container
 proc add(nb: var Nb, blk: NbBlock) =
+  nb.blk = blk
   if nb.containers.len == 0:
     nb.doc.blocks.add blk
   else:
@@ -113,8 +113,8 @@ type
   NbText = ref object of NbBlock
     text: string
 template nbText*(ttext: string) =
-  nb.blk = NbText(text: ttext, kind: "NbText")
-  nb.add nb.blk
+  let blk = NbText(text: ttext, kind: "NbText")
+  nb.add blk
 func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbText
   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
@@ -133,8 +133,8 @@ type
   NbImage = ref object of NbBlock
     url: string
 template nbImage*(turl: string) =
-  nb.blk = NbImage(url: turl, kind: "NbImage")
-  nb.add nb.blk
+  let blk = NbImage(url: turl, kind: "NbImage")
+  nb.add blk
 func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbImage
   "<img src= '" & blk.url & "'>"
@@ -152,7 +152,6 @@ type
     summary: string
 template nbDetails*(tsummary: string, body: untyped) =
   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
-  nb.blk = blk
   nb.withContainer(blk):
     body
 
@@ -164,37 +163,6 @@ func NbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
   
 nbToHtml.funcs["NbDetails"] = NbDetailsToHtml
 addNbBlockToJson(NbDetails)
-proc dumpHook*(s: var string, v: NbDetails) =
-  s.add '{'
-  var i = 0
-  when compiles(for k, e in v.pairs: discard):
-    # Tables and table like objects.
-    for k, e in v.pairs:
-      if i > 0:
-        s.add ','
-      s.dumpHook(k)
-      s.add ':'
-      s.dumpHook(e)
-      inc i
-  else:
-    # Normal objects.
-    for k, e in v[].fieldPairs:
-      when compiles(skipHook(type(v), k)):
-        when skipHook(type(v), k):
-          discard
-        else:
-          if i > 0:
-            s.add ','
-          s.dumpKey(k)
-          s.dumpHook(e)
-          inc i
-      else:
-        if i > 0:
-          s.add ','
-        s.dumpKey(k)
-        s.dumpHook(e)
-        inc i
-  s.add '}'
 
 
 when isMainModule:
@@ -203,6 +171,8 @@ when isMainModule:
   nbDetails("Click for details:"):
     nbText: "*hi*"
     nbImage("img.png")
+    nbDetails("go deeper"):
+      nbText("42")
   nbSave
   #[
 <!DOCTYPE html>
diff --git a/sandbox/notes.md b/sandbox/notes.md
index f22f5c0..d78cbd0 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -4,9 +4,10 @@
 - added NbContainer type, refactored NbDoc added NbDetails as example
 - FAILURE: serialization to json has issues!
 - alternative implementation of containers that does not use circular references
-  (simpler, no issues)
+  (simpler, no issues) [x]
   - add api a `nb.add` and `nb.withContainer(container)
 : body`
+- hidden nb.blk api in nb.add (we might remove it later) [x]
 ---
 ## Naming
 

From e338f67f23b250bcd436e2e1e3e4d530583a6826 Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Wed, 27 Mar 2024 17:07:48 +0100
Subject: [PATCH 18/73] update dev notes

---
 sandbox/notes.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/sandbox/notes.md b/sandbox/notes.md
index d78cbd0..b2d87e9 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,6 +1,14 @@
 ## getting back working on this
 
-### containers
+### Next steps:
+- implement `nbCode` in minib
+- implement `nbCodeFromJs` in minib
+- think if there are essentially other types of blocks we need to test with the new refactoring
+- if not go ahead and implement sugar to implement custom blocks (and refactor)
+- clean up minib implementation
+- reimplement all of minib starting with the new minib poc
+
+### containers 👌
 - added NbContainer type, refactored NbDoc added NbDetails as example
 - FAILURE: serialization to json has issues!
 - alternative implementation of containers that does not use circular references
@@ -8,7 +16,9 @@
   - add api a `nb.add` and `nb.withContainer(container)
 : body`
 - hidden nb.blk api in nb.add (we might remove it later) [x]
+
 ---
+
 ## Naming
 
 - not sure I still like the name backend for the rendering engine

From ad3b14847ea156f36898fd749e96acc6c8852c9a Mon Sep 17 00:00:00 2001
From: Pietro Peterlongo <pietro.peterlongo@gmail.com>
Date: Thu, 28 Mar 2024 10:07:14 +0100
Subject: [PATCH 19/73] implement nbCode

---
 sandbox/minib.nim                   | 45 ----------------
 sandbox/minib/capture.nim           | 30 +++++++++++
 sandbox/{minib3 => minib}/minib.nim | 83 ++++++++++++++++++++++-------
 sandbox/minib2.nim                  | 12 -----
 sandbox/notes.md                    |  4 +-
 5 files changed, 97 insertions(+), 77 deletions(-)
 delete mode 100644 sandbox/minib.nim
 create mode 100644 sandbox/minib/capture.nim
 rename sandbox/{minib3 => minib}/minib.nim (68%)
 delete mode 100644 sandbox/minib2.nim

diff --git a/sandbox/minib.nim b/sandbox/minib.nim
deleted file mode 100644
index 18d6297..0000000
--- a/sandbox/minib.nim
+++ /dev/null
@@ -1,45 +0,0 @@
-# minib (a mini nimib)
-import strformat, macros
-
-macro toStr*(body: untyped): string =
-  (body.toStrLit)
-
-type
-  NbBase* = ref object of RootObj
-    partial*: string
-  NbText* = ref object of NbBase
-    text*: string
-  NbCode* = ref object of NbBase
-    code*: string
-    output*: string
-  NbImage* = ref object of NbBase
-    url*: string
-  NbSummaryDetails* = ref object of NbBase
-    summary*: string
-    details*: seq[NbBase]
-  NbDoc* = object
-    blocks*: seq[NbBase]
-
-template nbInit =
-  var nb {. inject .}: NbDoc
-
-template nbImage(url2: string) =
-  nb.blocks.add NbImage(
-    url: url2,
-    partial: "<img href=\"{{url}}\"><img>"
-  )
-
-# alternative api, similar to python, not used in nimib
-proc image(nb: var NbDoc, url: string) =
-  nb.blocks.add NbImage(url: url)
-
-when isMainModule:
-  import print
-
-  nbInit
-  nbImage: "img1"
-  nb.image("img2")
-
-  print nb
-  print nb.blocks[0].NbImage.url
-  print nb.blocks[1].NbImage.url
\ No newline at end of file
diff --git a/sandbox/minib/capture.nim b/sandbox/minib/capture.nim
new file mode 100644
index 0000000..c3884f2
--- /dev/null
+++ b/sandbox/minib/capture.nim
@@ -0,0 +1,30 @@
+## This submodule implements only one template to temporarily redirect and capture stdout during execution of a chunk of code.
+import tempfile
+
+# see https://stackoverflow.com/questions/64026829/how-to-temporarily-capture-stdout
+# Thanks, Clonk!
+
+# low level, should be Posix only but they happen to work on (my) Windows, too!
+proc dup(oldfd: FileHandle): FileHandle {.importc, header: "unistd.h".}
+proc dup2(oldfd: FileHandle, newfd: FileHandle): cint {.importc, header: "unistd.h".}
+
+template captureStdout*(ident: untyped, body: untyped) =
+  ## redirect stdout to a temporary file and captures output of body in ident
+  let
+    # Duplicate stdout
+    stdoutFileno = stdout.getFileHandle()
+    stdoutDupfd = dup(stdoutFileno)
+    # Create a new temporary file
+    (tmpFile, tmpFilename) = mkstemp(mode=fmWrite)
+    tmpFileFd: FileHandle = tmpFile.getFileHandle()  
+  discard dup2(tmpFileFd, stdoutFileno)  # writing to stdoutFileno now writes to tmpFile
+
+  body
+  flushFile stdout
+
+  # before reading tmpFile, flush and close
+  tmpFile.flushFile()  
+  tmpFile.close()
+  ident = readFile(tmpFileName)
+  # Restore stdout
+  discard dup2(stdoutDupfd, stdoutFileno)
\ No newline at end of file
diff --git a/sandbox/minib3/minib.nim b/sandbox/minib/minib.nim
similarity index 68%
rename from sandbox/minib3/minib.nim
rename to sandbox/minib/minib.nim
index 166fde8..f1ec2aa 100644
--- a/sandbox/minib3/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -51,6 +51,8 @@ proc parseHook*(s: string, i: var int, v: var NbBlock) =
   i = current_i
   # Parse the correct type
   let kind = n.kind
+  if kind notIn nbToJson:
+    raise ValueError.newException "cannot find kind in nbToJson: \"" & kind & '"' 
   v = nbToJson[kind](s, i)
 
 method dump(n: NbBlock): string =
@@ -82,6 +84,8 @@ func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
 addNbBlockToJson(NbDoc)
 
 # blocks.nim
+import std / macros
+
 proc add(nb: var Nb, blk: NbBlock) =
   nb.blk = blk
   if nb.containers.len == 0:
@@ -95,6 +99,12 @@ template withContainer(nb: var Nb, container: NbContainer, body: untyped) =
   body
   discard nb.containers.pop
 
+macro toStr*(body: untyped): string =
+  (body.toStrLit)
+
+# capture.nim
+import capture # imported from old nimib (new nimib does not run locally for me!)
+
 # nimib.nim
 import markdown
 
@@ -155,15 +165,36 @@ template nbDetails*(tsummary: string, body: untyped) =
   nb.withContainer(blk):
     body
 
-func NbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
+func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbDetails
   "<details><summary>" & blk.summary & "</summary>\n" &
   nbContainerToHtml(blk, nb) &
   "\n</details>"
   
-nbToHtml.funcs["NbDetails"] = NbDetailsToHtml
+nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
 addNbBlockToJson(NbDetails)
 
+type
+  NbCode = ref object of NbBlock
+    code: string
+    output: string
+    lang: string
+func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbCode
+  "<pre><code class=\"" & blk.lang & "\">\n" &
+  blk.code & '\n' &
+  "</code></pre>\n" &
+  "<pre>\n" &
+  blk.output & '\n' &
+  "</pre>"
+nbToHtml.funcs["NbCode"] = nbCodeToHtml
+addNbBlockToJson(NbCode)
+template nbCode*(body: untyped) =
+  let blk = NbCode(lang: "nim", kind: "NbCode")
+  nb.add blk
+  blk.code = toStr(body)
+  captureStdout(blk.output):
+    body
 
 when isMainModule:
   import print
@@ -173,16 +204,27 @@ when isMainModule:
     nbImage("img.png")
     nbDetails("go deeper"):
       nbText("42")
+  nbCode:
+    echo "hi"
   nbSave
   #[
 <!DOCTYPE html>
-<html><head></head>
-<body>
+<title>a nimib document<title>
+<details><summary>Click for details:</summary>
 <p><em>hi</em></p>
-
 <img src= 'img.png'>
-</body>
-</html>
+<details><summary>go deeper</summary>
+<p>42</p>
+</details>
+</details>
+<pre><code class="nim">
+
+echo "hi"
+</code></pre>
+<pre>
+hi
+
+</pre>
   ]#
 
   let docToJson = nb.doc.toJson()
@@ -192,18 +234,21 @@ when isMainModule:
   print docFromJson.blocks[0].NbDetails
   print docFromJson.blocks[0].NbDetails.blocks[0].NbText
   print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
+  print docFromJson.blocks[1].NbCode
   #[
-  print docToJson
-  print docFromJson
-  print docFromJson.blocks[0].NbDetails
-  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
-  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
-
+  docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
+docFromJson=NbDoc:ObjectType(
+  title: "a nimib document",
+  blocks: @[NbBlock:ObjectType(kind: "NbDetails"), NbBlock:ObjectType(kind: "NbCode")],
+  kind: "NbDoc"
+)
+docFromJson.blocks[0].NbDetails=NbDetails:ObjectType(
+  summary: "Click for details:",
+  blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage"), NbBlock:ObjectType(kind: "NbDetails")],
+  kind: "NbDetails"
+)
+docFromJson.blocks[0].NbDetails.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
+docFromJson.blocks[0].NbDetails.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage")
+docFromJson.blocks[1].NbCode=NbCode:ObjectType(code: "\necho "hi"", output: "hi\n", lang: "nim", kind: "NbCode")
   ]#
 
-  #[
-  docToJson="{"blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"}],"kind":"NbDoc"}"
-  docFromJson=NbDoc:ObjectType(blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage")], kind: "NbDoc")
-  docFromJson.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
-  docFromJson.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage") 
-  ]#
diff --git a/sandbox/minib2.nim b/sandbox/minib2.nim
deleted file mode 100644
index 10cca72..0000000
--- a/sandbox/minib2.nim
+++ /dev/null
@@ -1,12 +0,0 @@
-import json
-
-type
-  NbBlock* = ref object
-    command*: string
-    blocks*: seq[NbBlock]
-    data*: JsonNode
-  NbCode* = distinct NbBlock
-
-func code(b: NbCode): string =
-  assert "code" in b.NbBlock.data
-  assert b.NbBlock.data["code"].kind == JString
diff --git a/sandbox/notes.md b/sandbox/notes.md
index b2d87e9..d76a6a2 100644
--- a/sandbox/notes.md
+++ b/sandbox/notes.md
@@ -1,11 +1,13 @@
 ## getting back working on this
 
 ### Next steps:
-- implement `nbCode` in minib
+- implement `nbCode` in minib [x]
+  - add (old!) implementation of captureStdout to minib / capture [x]
 - implement `nbCodeFromJs` in minib
 - think if there are essentially other types of blocks we need to test with the new refactoring
 - if not go ahead and implement sugar to implement custom blocks (and refactor)
 - clean up minib implementation
+  - remove previous minibs and rename minib3 to minib [x]
 - reimplement all of minib starting with the new minib poc
 
 ### containers 👌

From 53c17fe9dddc735503041877d9026bad40550b0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 May 2024 15:10:55 +0200
Subject: [PATCH 20/73] copy jsutils to minib

---
 sandbox/minib/jsutils.nim | 228 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 228 insertions(+)
 create mode 100644 sandbox/minib/jsutils.nim

diff --git a/sandbox/minib/jsutils.nim b/sandbox/minib/jsutils.nim
new file mode 100644
index 0000000..de17e93
--- /dev/null
+++ b/sandbox/minib/jsutils.nim
@@ -0,0 +1,228 @@
+import std / [macros, macrocache, tables, strutils, strformat, sequtils, sugar, os, hashes]
+
+proc contains(tab: CacheTable, keyToCheck: string): bool =
+  for key, val in tab:
+    if key == keyToCheck:
+      return true
+  return false
+
+const bodyCache = CacheTable"bodyCache"
+
+macro addBody(key: string, s: untyped): untyped =
+  if key.strVal notin bodyCache:
+    bodyCache[key.strVal] = s
+
+proc degensymAst(n: NimNode) =
+  for i in 0 ..< n.len:
+    case n[i].kind
+    of nnkIdent, nnkSym:
+      let str = n[i].strVal
+      if "`gensym" in str:
+        let newStr = str.split("`gensym")[0]
+        let newSym = ident(newStr)
+        n[i] = newSym
+    else:
+      degensymAst(n[i])
+
+proc genCapturedAssignment(capturedVariables, capturedTypes: seq[NimNode]): tuple[code: NimNode, placeholders: seq[NimNode]] =
+  result.code = newStmtList()
+  # generate fromJSON loading and then add entire body afterwards
+  if capturedVariables.len > 0:
+    for (cap, capType) in zip(capturedVariables, capturedTypes):
+      let placeholder = gensym(ident="placeholder")
+      
+      let newSym = cap
+      result.placeholders.add placeholder
+      result.code.add quote do:
+        let `newSym` = parseJson(`placeholder`).to(`capType`) # we must gensym `cap` as well!
+
+macro nimToJsStringSecondStage*(key: static string, putCodeInBlock: static bool, captureVars: varargs[typed]): untyped =
+  let captureVars = toSeq(captureVars)
+
+  let captureTypes = collect:
+    for cap in captureVars:
+      cap.getTypeInst
+
+  # Get the untyped body from CacheTable
+  var body: NimNode
+  if key in bodyCache:
+    body = bodyCache[key]
+  else:
+    error(&"Nimib error: key {key} not in any of the tables. Please open an issue on Github with a minimal reproducible example")
+  # Now we have the body!
+  body = body.copyNimTree()
+  # 1. Generate the captured variable assignments and return placeholders
+  let (capAssignments, placeholders) = genCapturedAssignment(captureVars, captureTypes)
+  # 2. Stringify code
+  var code = newStmtList(capAssignments, body).copyNimTree()
+  code.degensymAst()
+
+  if putCodeInBlock:
+    code = newBlockStmt(code)
+  var codeText = code.toStrLit
+  # 3. Generate code which does the serialization and replacement of placeholders
+  let codeTextIdent = genSym(NimSymKind.nskVar, ident="codeText")
+  result = newStmtList()
+  result.add newVarStmt(codeTextIdent, codeText)
+  for i in 0 .. captureVars.high:
+    let placeholder = placeholders[i].repr.newLit
+    let varIdent = captureVars[i]
+    let serializedValue = quote do:
+      $(toJson(`varIdent`))
+    result.add quote do:
+      `codeTextIdent` = `codeTextIdent`.replace(`placeholder`, "\"\"\"" & `serializedValue` & "\"\"\"")
+  # return tuple of the transformed code to be compiled and the prettified code for visualization
+  body.degensymAst() # remove `gensym if code was written in a template
+  result.add nnkTupleConstr.newTree(codeTextIdent, body.toStrLit)
+    
+macro nimToJsString*(putCodeInBlock: static bool, args: varargs[untyped]): untyped =
+  if args.len == 0:
+    error("nbJsFromCode needs a code block to be passed", args)
+
+  let body = args[^1]
+  let captureVars =
+    if args.len == 1:
+      @[]
+    else:
+      args[0 ..< ^1]
+  
+  # Save UNTYPED body for access later. 
+  # It's important that it is untyped to be able to combine
+  # multiple code snippets.
+  let key = body.repr
+
+  result = newStmtList()
+  result.add quote do:
+    addBody(`key`, `body`)
+  var nextArgs = @[newLit(key), newLit(putCodeInBlock)]
+  nextArgs.add captureVars
+  result.add newCall("nimToJsStringSecondStage", nextArgs)
+
+macro nbKaraxCodeBackend*(rootId: untyped, args: varargs[untyped]) =
+  if args.len == 0:
+    error("nbKaraxCode needs a code block to be passed", args)
+  
+  let body = args[^1]
+  let captureVars =
+    if args.len == 1:
+      @[]
+    else:
+      args[0 ..< ^1]
+  
+  let newBody = quote do:
+    import karax / [kbase, karax, karaxdsl, vdom, compact, jstrutils, kdom]
+
+    var postRenderCallback: proc () = nil
+
+    template postRender(body: untyped) =
+      ## Must be called before karaxHtml!!!
+      proc tempProc () =
+        body
+      postRenderCallback = tempProc
+
+    template karaxHtml(body: untyped) =
+      proc createDom(): VNode =
+        result = buildHtml(tdiv):
+          body # html karax code
+      setRenderer(createDom, root=`rootId`.cstring, clientPostRenderCallback = postRenderCallback)
+
+    `body`
+
+  var callArgs = @[rootId]
+  callArgs.add captureVars
+  callArgs.add newBody
+
+  let call = newCall(ident"nbJsFromCodeOwnFile", callArgs)
+
+  result = call
+
+macro nbHappyxCodeBackend*(rootId: untyped, args: varargs[untyped]) =
+  if args.len == 0:
+    error("nbHappyxCode needs a code block to be passed", args)
+  let body = args[^1]
+  let captureVars =
+    if args.len == 1:
+      @[]
+    else:
+      args[0 ..< ^1]
+
+  let caller = body[^1][0]
+  if caller != ident"happyxRoutes":
+    error(fmt "{caller} != happyxRoutes: a happyxRoutes: block must terminate the nbHappyxCode block")
+
+  let happyxRoutesBody = body[^1][1]
+
+  let preHappyxRoutes =
+    if body.len == 1:
+      @[]
+    else:
+      body[0 ..< ^1]
+
+  var preRoutesCode = newStmtList()
+  for i in preHappyxRoutes.items:
+    preRoutesCode.add(i)
+
+  let imports = quote do:
+    import happyx, std/ strformat
+
+  let newBody = quote do:
+    `imports`
+    `preRoutesCode`
+    appRoutes(`rootId`):
+      `happyxRoutesBody`
+
+  var callArgs = @[rootId]
+  callArgs.add captureVars
+  callArgs.add newBody
+
+  let call = newCall(ident"nbJsFromCodeOwnFile", callArgs)
+  result = call
+
+#[ proc compileNimToJs*(doc: var NbDoc, blk: var NbBlock) =
+  let tempdir = getTempDir() / "nimib"
+  createDir(tempdir)
+  let (dir, filename, ext) = doc.thisFile.splitFile()
+  let nimfile = dir / (filename & "_nbCodeToJs_" & $doc.newId() & ext).RelativeFile
+  let jsfile = tempdir / &"out{hash(doc.thisFile)}.js"
+  var codeText = blk.context["transformedCode"].vString
+  let nbJsCounter = doc.nbJsCounter
+  doc.nbJsCounter += 1
+  var bumpGensymString = """
+import std/[macros, json]
+
+macro bumpGensym(n: static int) =
+  for i in 0 .. n:
+    let _ = gensym()
+
+"""
+  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
+  codeText = bumpGensymString & codeText
+  writeFile(nimfile, codeText)
+  let kxiname = "nimib_kxi_" & $doc.newId()
+  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
+  if errorCode != 0:
+    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
+  removeFile(nimfile)
+  let jscode = readFile(jsfile)
+  removeFile(jsfile)
+  blk.output = jscode
+  blk.context["output"] = jscode
+
+proc nbCollectAllNbJs*(doc: var NbDoc) =
+  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
+  var code = ""
+  for blk in doc.blocks:
+    if blk.command == "nbJsFromCode":
+      if blk.context["putAtTop"].vBool:
+        topCode.add "\n" & blk.context["transformedCode"].vString
+      else:
+        code.add "\n" & blk.context["transformedCode"].vString
+  code = topCode & "\n" & code
+
+  if not code.isEmptyOrWhitespace:
+    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
+    var blk = NbBlock(command: "nbJsFromCodeOwnFile", code: code, context: newContext(searchDirs = @[], partials = doc.partials), output: "")
+    blk.context["transformedCode"] = code
+    doc.blocks.add blk
+    doc.blk = blk
+ ]#
\ No newline at end of file

From b8333bad142773f3a02fde0214eba7d489d2437a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 May 2024 15:11:30 +0200
Subject: [PATCH 21/73] start implementing nbJsFromCode

---
 sandbox/minib/minib.nim | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index f1ec2aa..66aed42 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -107,6 +107,7 @@ import capture # imported from old nimib (new nimib does not run locally for me!
 
 # nimib.nim
 import markdown
+import jsutils
 
 template nbInit* =
   var nb {. inject .}: Nb
@@ -196,6 +197,23 @@ template nbCode*(body: untyped) =
   captureStdout(blk.output):
     body
 
+type
+  NbJsFromCode = ref object of NbBlock
+    code: string
+    transformedCode: string
+    putAtTop: bool
+func nbJsFromCodeToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbJsFromCode
+  blk.code
+nbToHtml.funcs["NbJsFromCode"] = nbJsFromCodeToHtml
+addNbBlockToJson(NbJsFromCode)
+template nbJsFromCode*(args: varargs[untyped]) =
+  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = NbJsFromCode(code: originalCode, transformedCode: transformedCode, putAtTop: false, kind: "NbJsFromCode")
+  nb.add blk
+
+
+
 when isMainModule:
   import print
   nbInit
@@ -206,6 +224,8 @@ when isMainModule:
       nbText("42")
   nbCode:
     echo "hi"
+  nbJsFromCode:
+    echo "bye"
   nbSave
   #[
 <!DOCTYPE html>
@@ -235,6 +255,7 @@ hi
   print docFromJson.blocks[0].NbDetails.blocks[0].NbText
   print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
   print docFromJson.blocks[1].NbCode
+  print docFromJson.blocks[2].NbJsFromCode
   #[
   docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
 docFromJson=NbDoc:ObjectType(

From 70dd4c8470633a7d769cca13428d2bd042b8ae92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 May 2024 15:27:09 +0200
Subject: [PATCH 22/73] add showCode parameter to NbJsFromCode

---
 sandbox/minib/minib.nim | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 66aed42..2b4a166 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -202,14 +202,18 @@ type
     code: string
     transformedCode: string
     putAtTop: bool
+    showCode: bool
 func nbJsFromCodeToHtml(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbJsFromCode
-  blk.code
+  if blk.showCode:
+    "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
+  else:
+    ""
 nbToHtml.funcs["NbJsFromCode"] = nbJsFromCodeToHtml
 addNbBlockToJson(NbJsFromCode)
 template nbJsFromCode*(args: varargs[untyped]) =
   let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = NbJsFromCode(code: originalCode, transformedCode: transformedCode, putAtTop: false, kind: "NbJsFromCode")
+  let blk = NbJsFromCode(code: originalCode, transformedCode: transformedCode, putAtTop: false, showCode: false, kind: "NbJsFromCode")
   nb.add blk
 
 

From 45d2ca62222528122de8d9989b24f7d7ef2fa1e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 May 2024 21:03:43 +0200
Subject: [PATCH 23/73] hacky nbJsFromCode implementation

---
 sandbox/minib/minib.nim | 94 +++++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 3 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 2b4a166..68239dd 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -1,6 +1,7 @@
 # types.nim
-import tables
-
+import std/[tables, os, strformat, hashes]
+import "$nim/compiler/pathutils"
+import print
 type
   NbBlock = ref object of RootObj
     kind: string
@@ -11,6 +12,8 @@ type
     blocks: seq[NbBlock]
   NbDoc = ref object of NbContainer
     title: string
+    id: int
+    nbJsCounter: int
   Nb = object
     blk: NbBlock # last block processed
     doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
@@ -24,6 +27,11 @@ func render(nb: Nb, blk: NbBlock): string =
   else:
     ""
 
+proc newId*(doc: var NbDoc): int =
+  ## Provides a unique integer each time it is called
+  result = doc.id
+  inc doc.id
+
 # globals.nim
 var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
 var nbToHtml: NbRender # since we need it for json, let's make it also for html
@@ -78,7 +86,7 @@ func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
 
 func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   "<!DOCTYPE html>\n" &
-  "<title>" & blk.NbDoc.title & "<title>\n" &
+  "<title>" & blk.NbDoc.title & "</title>\n" &
   nbContainerToHtml(blk, nb)
   
 addNbBlockToJson(NbDoc)
@@ -116,7 +124,10 @@ template nbInit* =
   nb.backend = nbToHtml
 
 template nbSave* =
+  echo "saving"
+  nbCollectAllNbJs(nb)
   echo nb.render nb.doc
+  writeFile("test.html", nb.render(nb.doc))
 
 # all other blocks are in a sense all custom blocks
 # we could add sugar for common block creation
@@ -216,6 +227,82 @@ template nbJsFromCode*(args: varargs[untyped]) =
   let blk = NbJsFromCode(code: originalCode, transformedCode: transformedCode, putAtTop: false, showCode: false, kind: "NbJsFromCode")
   nb.add blk
 
+type
+  NbJsFromCodeOwnFile = ref object of NbBlock
+    code: string
+    transformedCode: string
+    jsCode: string
+    showCode: bool
+func nbJsFromCodeOwnFileToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbJsFromCodeOwnFile
+  result =
+    if blk.showCode:
+      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
+    else:
+      ""
+  result &= &"<script>\n{blk.jsCode}\n</script>"
+nbToHtml.funcs["NbJsFromCodeOwnFile"] = nbJsFromCodeOwnFileToHtml
+addNbBlockToJson(NbJsFromCodeOwnFile)
+template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
+  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = NbJsFromCodeOwnFile(code: originalCode, transformedCode: transformedCode, showCode: false, kind: "NbJsFromCodeOwnFile")
+  nb.add blk
+
+# jsutils.nim (these currently require to know of NbJsFromCode and NbJsFromCodeOwnFile...)
+proc compileNimToJs*(nb: var Nb, blk: NbBlock): string =
+  let blk = blk.NbJsFromCodeOwnFile
+  let tempdir = getTempDir() / "nimib"
+  createDir(tempdir)
+  let (dir, filename, ext) = (getCurrentDir().AbsoluteDir, "js_file", ".nim")#doc.thisFile.splitFile()
+  let nimfile = dir / (filename & "_nbCodeToJs_" & $nb.doc.newId() & ext).RelativeFile
+  let jsfile = tempdir / &"out{hash(nb.doc.title)}.js"
+  var codeText = blk.transformedCode
+  let nbJsCounter = nb.doc.nbJsCounter
+  nb.doc.nbJsCounter += 1
+  var bumpGensymString = """
+import std/[macros, json]
+
+macro bumpGensym(n: static int) =
+  for i in 0 .. n:
+    let _ = gensym()
+
+"""
+  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
+  codeText = bumpGensymString & codeText
+  writeFile(nimfile, codeText)
+  let kxiname = "nimib_kxi_" & $nb.doc.newId()
+  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
+  if errorCode != 0:
+    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
+  removeFile(nimfile)
+  let jscode = readFile(jsfile)
+  removeFile(jsfile)
+  return jscode
+
+proc nbCollectAllNbJs*(nb: var Nb) =
+  echo "In code!"
+  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
+  var code = ""
+  for blk in nb.doc.blocks: # this won't work for containers, implement nb.flattenBlocks func
+    if blk.kind == "NbJsFromCode":
+      let blk = blk.NbJsFromCode
+      if blk.putAtTop:
+        topCode.add "\n" & blk.transformedCode
+      else:
+        code.add "\n" & blk.transformedCode
+  code = topCode & "\n" & code
+
+  print code
+  if not code.isEmptyOrWhitespace:
+    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
+    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
+    nb.add blk
+
+  # loop over all nbJsFromCodeOwnFile and compile them
+  for blk in nb.doc.blocks:
+    if blk.kind == "NbJsFromCodeOwnFile":
+      var blk = blk.NbJsFromCodeOwnFile
+      blk.jsCode = nb.compileNimToJs(blk)
 
 
 when isMainModule:
@@ -260,6 +347,7 @@ hi
   print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
   print docFromJson.blocks[1].NbCode
   print docFromJson.blocks[2].NbJsFromCode
+  print docFromJson.blocks[3].NbJsFromCodeOwnFile
   #[
   docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
 docFromJson=NbDoc:ObjectType(

From 73efd5161e0c2208cb9c6df90fb2966ccd8c3361 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 19 May 2024 10:53:28 +0200
Subject: [PATCH 24/73] use of syntex instead of checking kind

---
 sandbox/minib/minib.nim | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 68239dd..ea0ab36 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -284,7 +284,7 @@ proc nbCollectAllNbJs*(nb: var Nb) =
   var topCode = "" # placed at the top (nbJsFromCodeGlobal)
   var code = ""
   for blk in nb.doc.blocks: # this won't work for containers, implement nb.flattenBlocks func
-    if blk.kind == "NbJsFromCode":
+    if blk of NbJsFromCode:
       let blk = blk.NbJsFromCode
       if blk.putAtTop:
         topCode.add "\n" & blk.transformedCode
@@ -300,7 +300,7 @@ proc nbCollectAllNbJs*(nb: var Nb) =
 
   # loop over all nbJsFromCodeOwnFile and compile them
   for blk in nb.doc.blocks:
-    if blk.kind == "NbJsFromCodeOwnFile":
+    if blk of NbJsFromCodeOwnFile:
       var blk = blk.NbJsFromCodeOwnFile
       blk.jsCode = nb.compileNimToJs(blk)
 
@@ -316,7 +316,7 @@ when isMainModule:
   nbCode:
     echo "hi"
   nbJsFromCode:
-    echo "bye"
+    echo "bye!"
   nbSave
   #[
 <!DOCTYPE html>

From 08b5eeaa0c3b3c061579a4b8a920f6b78f2b13af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 19 May 2024 12:36:03 +0200
Subject: [PATCH 25/73] implement blocksFlattened func for container blocks and
 use it

---
 sandbox/minib/minib.nim | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index ea0ab36..7fc8448 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -32,6 +32,12 @@ proc newId*(doc: var NbDoc): int =
   result = doc.id
   inc doc.id
 
+func blocksFlattened*(doc: NbContainer): seq[NbBlock] =
+  for blk in doc.blocks:
+    result.add blk
+    if blk of NbContainer:
+      result.add blk.NbContainer.blocksFlattened()
+
 # globals.nim
 var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
 var nbToHtml: NbRender # since we need it for json, let's make it also for html
@@ -280,10 +286,9 @@ macro bumpGensym(n: static int) =
   return jscode
 
 proc nbCollectAllNbJs*(nb: var Nb) =
-  echo "In code!"
   var topCode = "" # placed at the top (nbJsFromCodeGlobal)
   var code = ""
-  for blk in nb.doc.blocks: # this won't work for containers, implement nb.flattenBlocks func
+  for blk in nb.doc.blocksFlattened:
     if blk of NbJsFromCode:
       let blk = blk.NbJsFromCode
       if blk.putAtTop:
@@ -292,14 +297,13 @@ proc nbCollectAllNbJs*(nb: var Nb) =
         code.add "\n" & blk.transformedCode
   code = topCode & "\n" & code
 
-  print code
   if not code.isEmptyOrWhitespace:
     # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
     let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
     nb.add blk
 
   # loop over all nbJsFromCodeOwnFile and compile them
-  for blk in nb.doc.blocks:
+  for blk in nb.doc.blocksFlattened:
     if blk of NbJsFromCodeOwnFile:
       var blk = blk.NbJsFromCodeOwnFile
       blk.jsCode = nb.compileNimToJs(blk)
@@ -315,8 +319,9 @@ when isMainModule:
       nbText("42")
   nbCode:
     echo "hi"
-  nbJsFromCode:
-    echo "bye!"
+  nbDetails("Hide js code:"):
+    nbJsFromCode:
+      echo "bye!"
   nbSave
   #[
 <!DOCTYPE html>
@@ -346,7 +351,7 @@ hi
   print docFromJson.blocks[0].NbDetails.blocks[0].NbText
   print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
   print docFromJson.blocks[1].NbCode
-  print docFromJson.blocks[2].NbJsFromCode
+  print docFromJson.blocks[2].NbDetails.blocks[0].NbJsFromCode
   print docFromJson.blocks[3].NbJsFromCodeOwnFile
   #[
   docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"

From 591f8ed8053fde817f55248f131edb3b57f17668 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 13 Oct 2024 20:27:23 +0200
Subject: [PATCH 26/73] start working on sugar  macro

---
 sandbox/minib/minib.nim | 82 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 81 insertions(+), 1 deletion(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 7fc8448..4f689f8 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -1,5 +1,5 @@
 # types.nim
-import std/[tables, os, strformat, hashes]
+import std/[tables, os, strformat, hashes, macros, genasts, strutils]
 import "$nim/compiler/pathutils"
 import print
 type
@@ -79,6 +79,81 @@ template dumpKey(s: var string, v: string) =
   const v2 = v.toJson() & ":"
   s.add v2
 
+proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
+  n.expectKind nnkCall
+  (n[0].strVal, n[1][0])
+
+# nimibSugar.nim
+macro newNbBlock(typeName: untyped, body: untyped): untyped =
+  # typeName is either `ident` or
+  # Infix
+  #   Ident "of"
+  #   Ident "nbImage"
+  #   Ident "NbBlock"
+
+  let (typeNameStr, parentType) =
+   if typeName.kind == nnkIdent:
+     (typeName.strVal, "NbBlock".ident)
+   else:
+     (typeName[1].strVal, typeName[2])
+
+  let capitalizedTypeName = typeNameStr.capitalizeAscii
+
+  # body is:
+  # StmtList
+  #   Call
+  #     Ident "url"
+  #     StmtList
+  #       Ident "string"
+  #   Call
+  #     Ident "burl"
+  #     StmtList
+  #       Asgn
+  #         Ident "int"
+  #         IntLit 1
+  #   Call
+  #     Ident "toHtml"
+  #     StmtList
+  #       DotExpr
+  #         Ident "blk"
+  #         Ident "url"
+
+  echo "Body:\n", body.treeRepr
+
+  var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
+  var toHtmlBody: NimNode
+  body.expectKind(nnkStmtList)
+  for n in body:
+    let (name, body) = n.parseCallStmt()
+    if eqIdent(name, "toHtml"):
+      toHtmlBody = body
+    else:
+      fields.add (name, body)
+
+  var fieldsList = nnkRecList.newTree()
+  for (fName, fType) in fields:
+    fieldsList.add newIdentDefs(fName.ident, fType)
+  let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
+    capitalizedTypeName.ident,
+    newEmptyNode(), # generic
+    nnkRefTy.newTree(
+      nnkObjectTy.newTree(
+        newEmptyNode(), # pragma
+        nnkOfInherit.newTree(
+          parentType
+        ),
+        fieldsList
+      )
+    )
+  ))
+
+  echo "Type:\n", typeDefinition.repr
+
+  # Next: generate initializer with prefilled kind
+  # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
+  # It's more predictable if it is like the user wrote it
+
+  assert false
 
 # themes.nim
 import std / strutils
@@ -175,6 +250,11 @@ newNbBlock(nbImage):
     "<img src= '" & blk.url & "'>"
 ]#
 
+newNbBlock(nbImage):
+  url: string
+  toHtml:
+    "<img src= '" & blk.url & "'>"
+
 type
   NbDetails = ref object of NbContainer
     summary: string

From a1c3d0b42c32e6057a726ecd4f1dead8e95c583c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Mon, 18 Nov 2024 19:32:26 +0100
Subject: [PATCH 27/73] fully implemented sugar

---
 sandbox/minib/minib.nim | 74 +++++++++++++++++++++++++++++++++--------
 1 file changed, 60 insertions(+), 14 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 4f689f8..25acf18 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -1,5 +1,5 @@
 # types.nim
-import std/[tables, os, strformat, hashes, macros, genasts, strutils]
+import std/[tables, os, strformat, hashes, macros, genasts, strutils, sequtils]
 import "$nim/compiler/pathutils"
 import print
 type
@@ -98,6 +98,7 @@ macro newNbBlock(typeName: untyped, body: untyped): untyped =
      (typeName[1].strVal, typeName[2])
 
   let capitalizedTypeName = typeNameStr.capitalizeAscii
+  let lowercasedTypeName = typeNameStr.toLower
 
   # body is:
   # StmtList
@@ -151,9 +152,47 @@ macro newNbBlock(typeName: untyped, body: untyped): untyped =
 
   # Next: generate initializer with prefilled kind
   # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
-  # It's more predictable if it is like the user wrote it
+  # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
 
-  assert false
+  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
+  var objectConstructor = nnkObjConstr.newTree(
+    capitalizedTypeName.ident
+  )
+  objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
+  for (fName, _) in fields:
+    objectConstructor.add newColonExpr(fName.ident, fName.ident)
+  var procBody = newStmtList(objectConstructor)
+
+  var procName = ident("new" & capitalizedTypeName)
+  let initializer = newProc(procName, procParams, procBody)
+
+  echo "init:\n", initializer.repr
+
+  # Next: generate nbImageToHtml from toHtmlBody
+  let renderProcName = (lowercasedTypeName & "ToHtml").ident
+  let renderProc = genAst(name = renderProcName, body = toHtmlBody, blk = ident"blk", nb = ident"nb", typeName=capitalizedTypeName.ident):
+    proc name*(blk: NbBlock, nb: Nb): string =
+      let blk = typeName(blk)
+      body
+
+
+  # Next: generate these lines:
+  # nbToHtml.funcs["NbImage"] = nbImageToHtml
+  # addNbBlockToJson(NbImage)
+  let hookAssignements = genAst(key = capitalizedTypeName.newLit, f = renderProcName, typeName = capitalizedTypeName.ident):
+    nbToHtml.funcs[key] = f
+    addNbBlockToJson(typeName)
+
+  result = newStmtList(
+    typeDefinition,
+    initializer,
+    renderProc,
+    hookAssignements
+  )
+
+  echo result.repr
+
+  #assert false
 
 # themes.nim
 import std / strutils
@@ -232,17 +271,17 @@ newNbBlock(nbText):
       markdown(blk.text, config=initGfmConfig())
 ]#
 
-type
-  NbImage = ref object of NbBlock
-    url: string
-template nbImage*(turl: string) =
-  let blk = NbImage(url: turl, kind: "NbImage")
-  nb.add blk
-func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbImage
-  "<img src= '" & blk.url & "'>"
-nbToHtml.funcs["NbImage"] = nbImageToHtml
-addNbBlockToJson(NbImage)
+# type
+#   NbImage = ref object of NbBlock
+#     url: string
+# template nbImage*(turl: string) =
+#   let blk = NbImage(url: turl, kind: "NbImage")
+#   nb.add blk
+# func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbImage
+#   "<img src= '" & blk.url & "'>"
+# nbToHtml.funcs["NbImage"] = nbImageToHtml
+# addNbBlockToJson(NbImage)
 #[ the above could be shortened with sugar to:
 newNbBlock(nbImage):
   url: string
@@ -255,6 +294,13 @@ newNbBlock(nbImage):
   toHtml:
     "<img src= '" & blk.url & "'>"
 
+func image*(nb: var Nb, url: string) =
+  let blk = newNbImage(url=url)
+  nb.add blk
+
+template nbImage*(url: string) =
+  nb.image(url)
+
 type
   NbDetails = ref object of NbContainer
     summary: string

From 7fa59a8adcf2dffc41524b353578d44ec99782f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Thu, 21 Nov 2024 21:15:11 +0100
Subject: [PATCH 28/73] rewrite nbText, nbDetails and nbCode using sugar

---
 sandbox/minib/minib.nim | 121 ++++++++++++++++++++++++++--------------
 1 file changed, 79 insertions(+), 42 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 25acf18..977b488 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -251,25 +251,31 @@ template nbSave* =
 
 # all other blocks are in a sense all custom blocks
 # we could add sugar for common block creation
-type
-  NbText = ref object of NbBlock
-    text: string
-template nbText*(ttext: string) =
-  let blk = NbText(text: ttext, kind: "NbText")
-  nb.add blk
-func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbText
-  {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-    markdown(blk.text, config=initGfmConfig())
-nbToHtml.funcs["NbText"] = nbTextToHtml
-addNbBlockToJson(NbText)
-#[ the above could be shortened with sugar to:
+# type
+#   NbText = ref object of NbBlock
+#     text: string
+# template nbText*(ttext: string) =
+#   let blk = NbText(text: ttext, kind: "NbText")
+#   nb.add blk
+# func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbText
+#   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+#     markdown(blk.text, config=initGfmConfig())
+# nbToHtml.funcs["NbText"] = nbTextToHtml
+# addNbBlockToJson(NbText)
+
 newNbBlock(nbText):
   text: string
   toHtml:
     {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
       markdown(blk.text, config=initGfmConfig())
-]#
+
+proc text*(nb: var Nb, text: string) =
+  let blk = newNbText(text=text)
+  nb.add blk
+
+template nbText(ttext: string) =
+  nb.text(ttext)
 
 # type
 #   NbImage = ref object of NbBlock
@@ -301,40 +307,71 @@ func image*(nb: var Nb, url: string) =
 template nbImage*(url: string) =
   nb.image(url)
 
-type
-  NbDetails = ref object of NbContainer
-    summary: string
+# type
+#   NbDetails = ref object of NbContainer
+#     summary: string
+# template nbDetails*(tsummary: string, body: untyped) =
+#   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
+#   nb.withContainer(blk):
+#     body
+
+# func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbDetails
+#   "<details><summary>" & blk.summary & "</summary>\n" &
+#   nbContainerToHtml(blk, nb) &
+#   "\n</details>"
+  
+# nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
+# addNbBlockToJson(NbDetails)
+
+newNbBlock(nbDetails of NbContainer):
+  summary: string
+  toHtml:
+    "<details><summary>" & blk.summary & "</summary>\n" &
+    nbContainerToHtml(blk, nb) &
+    "\n</details>"
+
 template nbDetails*(tsummary: string, body: untyped) =
-  let blk = NbDetails(summary: tsummary, kind: "NbDetails")
+  let blk = newNbDetails(summary=tsummary)
   nb.withContainer(blk):
     body
 
-func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbDetails
-  "<details><summary>" & blk.summary & "</summary>\n" &
-  nbContainerToHtml(blk, nb) &
-  "\n</details>"
-  
-nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
-addNbBlockToJson(NbDetails)
+# type
+#   NbCode = ref object of NbBlock
+#     code: string
+#     output: string
+#     lang: string
+# func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbCode
+#   "<pre><code class=\"" & blk.lang & "\">\n" &
+#   blk.code & '\n' &
+#   "</code></pre>\n" &
+#   "<pre>\n" &
+#   blk.output & '\n' &
+#   "</pre>"
+# nbToHtml.funcs["NbCode"] = nbCodeToHtml
+# addNbBlockToJson(NbCode)
+# template nbCode*(body: untyped) =
+#   let blk = NbCode(lang: "nim", kind: "NbCode")
+#   nb.add blk
+#   blk.code = toStr(body)
+#   captureStdout(blk.output):
+#     body
+
+newNbBlock(nbCode):
+  code: string
+  output: string
+  lang: string
+  toHtml:
+    "<pre><code class=\"" & blk.lang & "\">\n" &
+    blk.code & '\n' &
+    "</code></pre>\n" &
+    "<pre>\n" &
+    blk.output & '\n' &
+    "</pre>"
 
-type
-  NbCode = ref object of NbBlock
-    code: string
-    output: string
-    lang: string
-func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbCode
-  "<pre><code class=\"" & blk.lang & "\">\n" &
-  blk.code & '\n' &
-  "</code></pre>\n" &
-  "<pre>\n" &
-  blk.output & '\n' &
-  "</pre>"
-nbToHtml.funcs["NbCode"] = nbCodeToHtml
-addNbBlockToJson(NbCode)
 template nbCode*(body: untyped) =
-  let blk = NbCode(lang: "nim", kind: "NbCode")
+  let blk = newNbCode(code="", output="", lang="nim")
   nb.add blk
   blk.code = toStr(body)
   captureStdout(blk.output):

From 571f22e1a7d6012d72ebc851d9bcd61f891e9a19 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 31 Jan 2025 19:53:18 +0100
Subject: [PATCH 29/73] rewrite nbJs to sugar and write functional variants

---
 sandbox/minib/minib.nim | 1114 ++++++++++++++++++++-------------------
 1 file changed, 579 insertions(+), 535 deletions(-)

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index 977b488..d1feb5e 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -1,535 +1,579 @@
-# types.nim
-import std/[tables, os, strformat, hashes, macros, genasts, strutils, sequtils]
-import "$nim/compiler/pathutils"
-import print
-type
-  NbBlock = ref object of RootObj
-    kind: string
-  NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
-  NbRender = object
-    funcs: Table[string, NbRenderFunc]
-  NbContainer = ref object of NbBlock
-    blocks: seq[NbBlock]
-  NbDoc = ref object of NbContainer
-    title: string
-    id: int
-    nbJsCounter: int
-  Nb = object
-    blk: NbBlock # last block processed
-    doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
-    containers: seq[NbContainer] # current container
-    backend: NbRender # current backend
-
-# this needs to be know for all container blocks not sure whether to put it in types
-func render(nb: Nb, blk: NbBlock): string =
-  if blk.kind in nb.backend.funcs:
-    nb.backend.funcs[blk.kind](blk, nb)
-  else:
-    ""
-
-proc newId*(doc: var NbDoc): int =
-  ## Provides a unique integer each time it is called
-  result = doc.id
-  inc doc.id
-
-func blocksFlattened*(doc: NbContainer): seq[NbBlock] =
-  for blk in doc.blocks:
-    result.add blk
-    if blk of NbContainer:
-      result.add blk.NbContainer.blocksFlattened()
-
-# globals.nim
-var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
-var nbToHtml: NbRender # since we need it for json, let's make it also for html
-
-# jsons.nim
-import jsony
-
-template addNbBlockToJson*(kind: untyped) =
-  nbToJson[$kind] =
-    proc (s: string, i: var int): NbBlock =
-      var v: kind
-      new v
-      parseHook(s, i, v[])
-      result = v
-
-  method dump(n: kind): string =
-    n[].toJson()
-
-proc parseHook*(s: string, i: var int, v: var NbBlock) =
-  # First parse the typename
-  var n: NbBlock = NbBlock()
-  let current_i = i
-  parseHook(s, i, n[])
-  # Reset i
-  i = current_i
-  # Parse the correct type
-  let kind = n.kind
-  if kind notIn nbToJson:
-    raise ValueError.newException "cannot find kind in nbToJson: \"" & kind & '"' 
-  v = nbToJson[kind](s, i)
-
-method dump(n: NbBlock): string =
-    n[].toJson()
-
-proc dumpHook*(s: var string, v: NbBlock) =
-  s.add v.dump()
-
-template dumpKey(s: var string, v: string) =
-  const v2 = v.toJson() & ":"
-  s.add v2
-
-proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
-  n.expectKind nnkCall
-  (n[0].strVal, n[1][0])
-
-# nimibSugar.nim
-macro newNbBlock(typeName: untyped, body: untyped): untyped =
-  # typeName is either `ident` or
-  # Infix
-  #   Ident "of"
-  #   Ident "nbImage"
-  #   Ident "NbBlock"
-
-  let (typeNameStr, parentType) =
-   if typeName.kind == nnkIdent:
-     (typeName.strVal, "NbBlock".ident)
-   else:
-     (typeName[1].strVal, typeName[2])
-
-  let capitalizedTypeName = typeNameStr.capitalizeAscii
-  let lowercasedTypeName = typeNameStr.toLower
-
-  # body is:
-  # StmtList
-  #   Call
-  #     Ident "url"
-  #     StmtList
-  #       Ident "string"
-  #   Call
-  #     Ident "burl"
-  #     StmtList
-  #       Asgn
-  #         Ident "int"
-  #         IntLit 1
-  #   Call
-  #     Ident "toHtml"
-  #     StmtList
-  #       DotExpr
-  #         Ident "blk"
-  #         Ident "url"
-
-  echo "Body:\n", body.treeRepr
-
-  var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
-  var toHtmlBody: NimNode
-  body.expectKind(nnkStmtList)
-  for n in body:
-    let (name, body) = n.parseCallStmt()
-    if eqIdent(name, "toHtml"):
-      toHtmlBody = body
-    else:
-      fields.add (name, body)
-
-  var fieldsList = nnkRecList.newTree()
-  for (fName, fType) in fields:
-    fieldsList.add newIdentDefs(fName.ident, fType)
-  let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
-    capitalizedTypeName.ident,
-    newEmptyNode(), # generic
-    nnkRefTy.newTree(
-      nnkObjectTy.newTree(
-        newEmptyNode(), # pragma
-        nnkOfInherit.newTree(
-          parentType
-        ),
-        fieldsList
-      )
-    )
-  ))
-
-  echo "Type:\n", typeDefinition.repr
-
-  # Next: generate initializer with prefilled kind
-  # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
-  # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
-
-  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
-  var objectConstructor = nnkObjConstr.newTree(
-    capitalizedTypeName.ident
-  )
-  objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
-  for (fName, _) in fields:
-    objectConstructor.add newColonExpr(fName.ident, fName.ident)
-  var procBody = newStmtList(objectConstructor)
-
-  var procName = ident("new" & capitalizedTypeName)
-  let initializer = newProc(procName, procParams, procBody)
-
-  echo "init:\n", initializer.repr
-
-  # Next: generate nbImageToHtml from toHtmlBody
-  let renderProcName = (lowercasedTypeName & "ToHtml").ident
-  let renderProc = genAst(name = renderProcName, body = toHtmlBody, blk = ident"blk", nb = ident"nb", typeName=capitalizedTypeName.ident):
-    proc name*(blk: NbBlock, nb: Nb): string =
-      let blk = typeName(blk)
-      body
-
-
-  # Next: generate these lines:
-  # nbToHtml.funcs["NbImage"] = nbImageToHtml
-  # addNbBlockToJson(NbImage)
-  let hookAssignements = genAst(key = capitalizedTypeName.newLit, f = renderProcName, typeName = capitalizedTypeName.ident):
-    nbToHtml.funcs[key] = f
-    addNbBlockToJson(typeName)
-
-  result = newStmtList(
-    typeDefinition,
-    initializer,
-    renderProc,
-    hookAssignements
-  )
-
-  echo result.repr
-
-  #assert false
-
-# themes.nim
-import std / strutils
-
-func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbContainer
-  for b in blk.blocks:
-    result.add nb.render(b).strip & '\n'
-  result.strip
-# should I add this to the global object?
-
-func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
-  "<!DOCTYPE html>\n" &
-  "<title>" & blk.NbDoc.title & "</title>\n" &
-  nbContainerToHtml(blk, nb)
-  
-addNbBlockToJson(NbDoc)
-
-# blocks.nim
-import std / macros
-
-proc add(nb: var Nb, blk: NbBlock) =
-  nb.blk = blk
-  if nb.containers.len == 0:
-    nb.doc.blocks.add blk
-  else:
-    nb.containers[^1].blocks.add blk
-
-template withContainer(nb: var Nb, container: NbContainer, body: untyped) =
-  nb.add container
-  nb.containers.add container
-  body
-  discard nb.containers.pop
-
-macro toStr*(body: untyped): string =
-  (body.toStrLit)
-
-# capture.nim
-import capture # imported from old nimib (new nimib does not run locally for me!)
-
-# nimib.nim
-import markdown
-import jsutils
-
-template nbInit* =
-  var nb {. inject .}: Nb
-  nb.doc = NbDoc(kind: "NbDoc", title: "a nimib document")
-  nbToHtml.funcs["NbDoc"] = nbDocToHtml
-  nb.backend = nbToHtml
-
-template nbSave* =
-  echo "saving"
-  nbCollectAllNbJs(nb)
-  echo nb.render nb.doc
-  writeFile("test.html", nb.render(nb.doc))
-
-# all other blocks are in a sense all custom blocks
-# we could add sugar for common block creation
-# type
-#   NbText = ref object of NbBlock
-#     text: string
-# template nbText*(ttext: string) =
-#   let blk = NbText(text: ttext, kind: "NbText")
-#   nb.add blk
-# func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbText
-#   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-#     markdown(blk.text, config=initGfmConfig())
-# nbToHtml.funcs["NbText"] = nbTextToHtml
-# addNbBlockToJson(NbText)
-
-newNbBlock(nbText):
-  text: string
-  toHtml:
-    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-      markdown(blk.text, config=initGfmConfig())
-
-proc text*(nb: var Nb, text: string) =
-  let blk = newNbText(text=text)
-  nb.add blk
-
-template nbText(ttext: string) =
-  nb.text(ttext)
-
-# type
-#   NbImage = ref object of NbBlock
-#     url: string
-# template nbImage*(turl: string) =
-#   let blk = NbImage(url: turl, kind: "NbImage")
-#   nb.add blk
-# func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbImage
-#   "<img src= '" & blk.url & "'>"
-# nbToHtml.funcs["NbImage"] = nbImageToHtml
-# addNbBlockToJson(NbImage)
-#[ the above could be shortened with sugar to:
-newNbBlock(nbImage):
-  url: string
-  toHtml:
-    "<img src= '" & blk.url & "'>"
-]#
-
-newNbBlock(nbImage):
-  url: string
-  toHtml:
-    "<img src= '" & blk.url & "'>"
-
-func image*(nb: var Nb, url: string) =
-  let blk = newNbImage(url=url)
-  nb.add blk
-
-template nbImage*(url: string) =
-  nb.image(url)
-
-# type
-#   NbDetails = ref object of NbContainer
-#     summary: string
-# template nbDetails*(tsummary: string, body: untyped) =
-#   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
-#   nb.withContainer(blk):
-#     body
-
-# func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbDetails
-#   "<details><summary>" & blk.summary & "</summary>\n" &
-#   nbContainerToHtml(blk, nb) &
-#   "\n</details>"
-  
-# nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
-# addNbBlockToJson(NbDetails)
-
-newNbBlock(nbDetails of NbContainer):
-  summary: string
-  toHtml:
-    "<details><summary>" & blk.summary & "</summary>\n" &
-    nbContainerToHtml(blk, nb) &
-    "\n</details>"
-
-template nbDetails*(tsummary: string, body: untyped) =
-  let blk = newNbDetails(summary=tsummary)
-  nb.withContainer(blk):
-    body
-
-# type
-#   NbCode = ref object of NbBlock
-#     code: string
-#     output: string
-#     lang: string
-# func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbCode
-#   "<pre><code class=\"" & blk.lang & "\">\n" &
-#   blk.code & '\n' &
-#   "</code></pre>\n" &
-#   "<pre>\n" &
-#   blk.output & '\n' &
-#   "</pre>"
-# nbToHtml.funcs["NbCode"] = nbCodeToHtml
-# addNbBlockToJson(NbCode)
-# template nbCode*(body: untyped) =
-#   let blk = NbCode(lang: "nim", kind: "NbCode")
-#   nb.add blk
-#   blk.code = toStr(body)
-#   captureStdout(blk.output):
-#     body
-
-newNbBlock(nbCode):
-  code: string
-  output: string
-  lang: string
-  toHtml:
-    "<pre><code class=\"" & blk.lang & "\">\n" &
-    blk.code & '\n' &
-    "</code></pre>\n" &
-    "<pre>\n" &
-    blk.output & '\n' &
-    "</pre>"
-
-template nbCode*(body: untyped) =
-  let blk = newNbCode(code="", output="", lang="nim")
-  nb.add blk
-  blk.code = toStr(body)
-  captureStdout(blk.output):
-    body
-
-type
-  NbJsFromCode = ref object of NbBlock
-    code: string
-    transformedCode: string
-    putAtTop: bool
-    showCode: bool
-func nbJsFromCodeToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbJsFromCode
-  if blk.showCode:
-    "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
-  else:
-    ""
-nbToHtml.funcs["NbJsFromCode"] = nbJsFromCodeToHtml
-addNbBlockToJson(NbJsFromCode)
-template nbJsFromCode*(args: varargs[untyped]) =
-  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = NbJsFromCode(code: originalCode, transformedCode: transformedCode, putAtTop: false, showCode: false, kind: "NbJsFromCode")
-  nb.add blk
-
-type
-  NbJsFromCodeOwnFile = ref object of NbBlock
-    code: string
-    transformedCode: string
-    jsCode: string
-    showCode: bool
-func nbJsFromCodeOwnFileToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbJsFromCodeOwnFile
-  result =
-    if blk.showCode:
-      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
-    else:
-      ""
-  result &= &"<script>\n{blk.jsCode}\n</script>"
-nbToHtml.funcs["NbJsFromCodeOwnFile"] = nbJsFromCodeOwnFileToHtml
-addNbBlockToJson(NbJsFromCodeOwnFile)
-template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
-  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = NbJsFromCodeOwnFile(code: originalCode, transformedCode: transformedCode, showCode: false, kind: "NbJsFromCodeOwnFile")
-  nb.add blk
-
-# jsutils.nim (these currently require to know of NbJsFromCode and NbJsFromCodeOwnFile...)
-proc compileNimToJs*(nb: var Nb, blk: NbBlock): string =
-  let blk = blk.NbJsFromCodeOwnFile
-  let tempdir = getTempDir() / "nimib"
-  createDir(tempdir)
-  let (dir, filename, ext) = (getCurrentDir().AbsoluteDir, "js_file", ".nim")#doc.thisFile.splitFile()
-  let nimfile = dir / (filename & "_nbCodeToJs_" & $nb.doc.newId() & ext).RelativeFile
-  let jsfile = tempdir / &"out{hash(nb.doc.title)}.js"
-  var codeText = blk.transformedCode
-  let nbJsCounter = nb.doc.nbJsCounter
-  nb.doc.nbJsCounter += 1
-  var bumpGensymString = """
-import std/[macros, json]
-
-macro bumpGensym(n: static int) =
-  for i in 0 .. n:
-    let _ = gensym()
-
-"""
-  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
-  codeText = bumpGensymString & codeText
-  writeFile(nimfile, codeText)
-  let kxiname = "nimib_kxi_" & $nb.doc.newId()
-  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
-  if errorCode != 0:
-    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
-  removeFile(nimfile)
-  let jscode = readFile(jsfile)
-  removeFile(jsfile)
-  return jscode
-
-proc nbCollectAllNbJs*(nb: var Nb) =
-  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
-  var code = ""
-  for blk in nb.doc.blocksFlattened:
-    if blk of NbJsFromCode:
-      let blk = blk.NbJsFromCode
-      if blk.putAtTop:
-        topCode.add "\n" & blk.transformedCode
-      else:
-        code.add "\n" & blk.transformedCode
-  code = topCode & "\n" & code
-
-  if not code.isEmptyOrWhitespace:
-    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
-    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
-    nb.add blk
-
-  # loop over all nbJsFromCodeOwnFile and compile them
-  for blk in nb.doc.blocksFlattened:
-    if blk of NbJsFromCodeOwnFile:
-      var blk = blk.NbJsFromCodeOwnFile
-      blk.jsCode = nb.compileNimToJs(blk)
-
-
-when isMainModule:
-  import print
-  nbInit
-  nbDetails("Click for details:"):
-    nbText: "*hi*"
-    nbImage("img.png")
-    nbDetails("go deeper"):
-      nbText("42")
-  nbCode:
-    echo "hi"
-  nbDetails("Hide js code:"):
-    nbJsFromCode:
-      echo "bye!"
-  nbSave
-  #[
-<!DOCTYPE html>
-<title>a nimib document<title>
-<details><summary>Click for details:</summary>
-<p><em>hi</em></p>
-<img src= 'img.png'>
-<details><summary>go deeper</summary>
-<p>42</p>
-</details>
-</details>
-<pre><code class="nim">
-
-echo "hi"
-</code></pre>
-<pre>
-hi
-
-</pre>
-  ]#
-
-  let docToJson = nb.doc.toJson()
-  print docToJson
-  let docFromJson = docToJson.fromJson(NbDoc) # but now this fails
-  print docFromJson
-  print docFromJson.blocks[0].NbDetails
-  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
-  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
-  print docFromJson.blocks[1].NbCode
-  print docFromJson.blocks[2].NbDetails.blocks[0].NbJsFromCode
-  print docFromJson.blocks[3].NbJsFromCodeOwnFile
-  #[
-  docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
-docFromJson=NbDoc:ObjectType(
-  title: "a nimib document",
-  blocks: @[NbBlock:ObjectType(kind: "NbDetails"), NbBlock:ObjectType(kind: "NbCode")],
-  kind: "NbDoc"
-)
-docFromJson.blocks[0].NbDetails=NbDetails:ObjectType(
-  summary: "Click for details:",
-  blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage"), NbBlock:ObjectType(kind: "NbDetails")],
-  kind: "NbDetails"
-)
-docFromJson.blocks[0].NbDetails.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
-docFromJson.blocks[0].NbDetails.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage")
-docFromJson.blocks[1].NbCode=NbCode:ObjectType(code: "\necho "hi"", output: "hi\n", lang: "nim", kind: "NbCode")
-  ]#
-
+# types.nim
+import std/[tables, os, strformat, hashes, macros, genasts, strutils, sequtils]
+import "$nim/compiler/pathutils"
+import print
+type
+  NbBlock = ref object of RootObj
+    kind: string
+  NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
+  NbRender = object
+    funcs: Table[string, NbRenderFunc]
+  NbContainer = ref object of NbBlock
+    blocks: seq[NbBlock]
+  NbDoc = ref object of NbContainer
+    title: string
+    id: int
+    nbJsCounter: int
+  Nb = object
+    blk: NbBlock # last block processed
+    doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
+    containers: seq[NbContainer] # current container
+    backend: NbRender # current backend
+
+# this needs to be know for all container blocks not sure whether to put it in types
+func render(nb: Nb, blk: NbBlock): string =
+  if blk.kind in nb.backend.funcs:
+    nb.backend.funcs[blk.kind](blk, nb)
+  else:
+    ""
+
+proc newId*(doc: var NbDoc): int =
+  ## Provides a unique integer each time it is called
+  result = doc.id
+  inc doc.id
+
+func blocksFlattened*(doc: NbContainer): seq[NbBlock] =
+  for blk in doc.blocks:
+    result.add blk
+    if blk of NbContainer:
+      result.add blk.NbContainer.blocksFlattened()
+
+# globals.nim
+var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
+var nbToHtml: NbRender # since we need it for json, let's make it also for html
+
+# jsons.nim
+import jsony
+
+template addNbBlockToJson*(kind: untyped) =
+  nbToJson[$kind] =
+    proc (s: string, i: var int): NbBlock =
+      var v: kind
+      new v
+      parseHook(s, i, v[])
+      result = v
+
+  method dump(n: kind): string =
+    n[].toJson()
+
+proc parseHook*(s: string, i: var int, v: var NbBlock) =
+  # First parse the typename
+  var n: NbBlock = NbBlock()
+  let current_i = i
+  parseHook(s, i, n[])
+  # Reset i
+  i = current_i
+  # Parse the correct type
+  let kind = n.kind
+  if kind notIn nbToJson:
+    raise ValueError.newException "cannot find kind in nbToJson: \"" & kind & '"' 
+  v = nbToJson[kind](s, i)
+
+method dump(n: NbBlock): string =
+    n[].toJson()
+
+proc dumpHook*(s: var string, v: NbBlock) =
+  s.add v.dump()
+
+template dumpKey(s: var string, v: string) =
+  const v2 = v.toJson() & ":"
+  s.add v2
+
+proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
+  n.expectKind nnkCall
+  (n[0].strVal, n[1][0])
+
+# nimibSugar.nim
+macro newNbBlock(typeName: untyped, body: untyped): untyped =
+  # typeName is either `ident` or
+  # Infix
+  #   Ident "of"
+  #   Ident "nbImage"
+  #   Ident "NbBlock"
+
+  let (typeNameStr, parentType) =
+   if typeName.kind == nnkIdent:
+     (typeName.strVal, "NbBlock".ident)
+   else:
+     (typeName[1].strVal, typeName[2])
+
+  let capitalizedTypeName = typeNameStr.capitalizeAscii
+  let lowercasedTypeName = typeNameStr.toLower
+
+  # body is:
+  # StmtList
+  #   Call
+  #     Ident "url"
+  #     StmtList
+  #       Ident "string"
+  #   Call
+  #     Ident "burl"
+  #     StmtList
+  #       Asgn
+  #         Ident "int"
+  #         IntLit 1
+  #   Call
+  #     Ident "toHtml"
+  #     StmtList
+  #       DotExpr
+  #         Ident "blk"
+  #         Ident "url"
+
+  echo "Body:\n", body.treeRepr
+
+  var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
+  var toHtmlBody: NimNode
+  body.expectKind(nnkStmtList)
+  for n in body:
+    let (name, body) = n.parseCallStmt()
+    if eqIdent(name, "toHtml"):
+      toHtmlBody = body
+    else:
+      fields.add (name, body)
+
+  var fieldsList = nnkRecList.newTree()
+  for (fName, fType) in fields:
+    fieldsList.add newIdentDefs(fName.ident, fType)
+  let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
+    capitalizedTypeName.ident,
+    newEmptyNode(), # generic
+    nnkRefTy.newTree(
+      nnkObjectTy.newTree(
+        newEmptyNode(), # pragma
+        nnkOfInherit.newTree(
+          parentType
+        ),
+        fieldsList
+      )
+    )
+  ))
+
+  echo "Type:\n", typeDefinition.repr
+
+  # Next: generate initializer with prefilled kind
+  # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
+  # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
+
+  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
+  var objectConstructor = nnkObjConstr.newTree(
+    capitalizedTypeName.ident
+  )
+  objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
+  for (fName, _) in fields:
+    objectConstructor.add newColonExpr(fName.ident, fName.ident)
+  var procBody = newStmtList(objectConstructor)
+
+  var procName = ident("new" & capitalizedTypeName)
+  let initializer = newProc(procName, procParams, procBody)
+
+  echo "init:\n", initializer.repr
+
+  # Next: generate nbImageToHtml from toHtmlBody
+  let renderProcName = (lowercasedTypeName & "ToHtml").ident
+  let renderProc = genAst(name = renderProcName, body = toHtmlBody, blk = ident"blk", nb = ident"nb", typeName=capitalizedTypeName.ident):
+    proc name*(blk: NbBlock, nb: Nb): string =
+      let blk = typeName(blk)
+      body
+
+
+  # Next: generate these lines:
+  # nbToHtml.funcs["NbImage"] = nbImageToHtml
+  # addNbBlockToJson(NbImage)
+  # should we make this into a proc instead so it can be used in the non-sugar variant as well?
+  let hookAssignements = genAst(key = capitalizedTypeName.newLit, f = renderProcName, typeName = capitalizedTypeName.ident):
+    nbToHtml.funcs[key] = f
+    addNbBlockToJson(typeName)
+
+  result = newStmtList(
+    typeDefinition,
+    initializer,
+    renderProc,
+    hookAssignements
+  )
+
+  echo result.repr
+
+  #assert false
+
+# themes.nim
+import std / strutils
+
+func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbContainer
+  for b in blk.blocks:
+    result.add nb.render(b).strip & '\n'
+  result.strip
+# should I add this to the global object?
+
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  "<!DOCTYPE html>\n" &
+  "<title>" & blk.NbDoc.title & "</title>\n" &
+  nbContainerToHtml(blk, nb)
+  
+addNbBlockToJson(NbDoc)
+
+# blocks.nim
+import std / macros
+
+proc add(nb: var Nb, blk: NbBlock) =
+  nb.blk = blk
+  if nb.containers.len == 0:
+    nb.doc.blocks.add blk
+  else:
+    nb.containers[^1].blocks.add blk
+
+template withContainer(nb: var Nb, container: NbContainer, body: untyped) =
+  nb.add container
+  nb.containers.add container
+  body
+  discard nb.containers.pop
+
+macro toStr*(body: untyped): string =
+  (body.toStrLit)
+
+# capture.nim
+import capture # imported from old nimib (new nimib does not run locally for me!)
+
+# nimib.nim
+import markdown
+import jsutils
+
+template nbInit* =
+  var nb {. inject .}: Nb
+  nb.doc = NbDoc(kind: "NbDoc", title: "a nimib document")
+  nbToHtml.funcs["NbDoc"] = nbDocToHtml
+  nb.backend = nbToHtml
+
+template nbSave* =
+  echo "saving"
+  nbCollectAllNbJs(nb)
+  echo nb.render nb.doc
+  writeFile("test.html", nb.render(nb.doc))
+
+# all other blocks are in a sense all custom blocks
+# we could add sugar for common block creation
+# type
+#   NbText = ref object of NbBlock
+#     text: string
+# template nbText*(ttext: string) =
+#   let blk = NbText(text: ttext, kind: "NbText")
+#   nb.add blk
+# func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbText
+#   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+#     markdown(blk.text, config=initGfmConfig())
+# nbToHtml.funcs["NbText"] = nbTextToHtml
+# addNbBlockToJson(NbText)
+
+newNbBlock(nbText):
+  text: string
+  toHtml:
+    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+      markdown(blk.text, config=initGfmConfig())
+
+proc text*(nb: var Nb, text: string) =
+  let blk = newNbText(text=text)
+  nb.add blk
+
+template nbText(ttext: string) =
+  nb.text(ttext)
+
+# type
+#   NbImage = ref object of NbBlock
+#     url: string
+# template nbImage*(turl: string) =
+#   let blk = NbImage(url: turl, kind: "NbImage")
+#   nb.add blk
+# func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbImage
+#   "<img src= '" & blk.url & "'>"
+# nbToHtml.funcs["NbImage"] = nbImageToHtml
+# addNbBlockToJson(NbImage)
+#[ the above could be shortened with sugar to:
+newNbBlock(nbImage):
+  url: string
+  toHtml:
+    "<img src= '" & blk.url & "'>"
+]#
+
+newNbBlock(nbImage):
+  url: string
+  toHtml:
+    "<img src= '" & blk.url & "'>"
+
+func image*(nb: var Nb, url: string) =
+  let blk = newNbImage(url=url)
+  nb.add blk
+
+template nbImage*(url: string) =
+  nb.image(url)
+
+# type
+#   NbDetails = ref object of NbContainer
+#     summary: string
+# template nbDetails*(tsummary: string, body: untyped) =
+#   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
+#   nb.withContainer(blk):
+#     body
+
+# func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbDetails
+#   "<details><summary>" & blk.summary & "</summary>\n" &
+#   nbContainerToHtml(blk, nb) &
+#   "\n</details>"
+  
+# nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
+# addNbBlockToJson(NbDetails)
+
+newNbBlock(nbDetails of NbContainer):
+  summary: string
+  toHtml:
+    "<details><summary>" & blk.summary & "</summary>\n" &
+    nbContainerToHtml(blk, nb) &
+    "\n</details>"
+
+template details*(nb: var Nb, tsummary: string, body: untyped) =
+  let blk = newNbDetails(summary=tsummary)
+  nb.withContainer(blk):
+    body
+
+template nbDetails*(tsummary: string, body: untyped) =
+  nb.details(tsummary):
+    body
+
+# type
+#   NbCode = ref object of NbBlock
+#     code: string
+#     output: string
+#     lang: string
+# func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
+#   let blk = blk.NbCode
+#   "<pre><code class=\"" & blk.lang & "\">\n" &
+#   blk.code & '\n' &
+#   "</code></pre>\n" &
+#   "<pre>\n" &
+#   blk.output & '\n' &
+#   "</pre>"
+# nbToHtml.funcs["NbCode"] = nbCodeToHtml
+# addNbBlockToJson(NbCode)
+# template nbCode*(body: untyped) =
+#   let blk = NbCode(lang: "nim", kind: "NbCode")
+#   nb.add blk
+#   blk.code = toStr(body)
+#   captureStdout(blk.output):
+#     body
+
+newNbBlock(nbCode):
+  code: string
+  output: string
+  lang: string
+  toHtml:
+    "<pre><code class=\"" & blk.lang & "\">\n" &
+    blk.code & '\n' &
+    "</code></pre>\n" &
+    "<pre>\n" &
+    blk.output & '\n' &
+    "</pre>"
+
+template code*(nb: var Nb, body: untyped) =
+  let blk = newNbCode(code="", output="", lang="nim")
+  nb.add blk
+  blk.code = toStr(body)
+  captureStdout(blk.output):
+    body
+
+template nbCode*(body: untyped) =
+  nb.code:
+    body
+
+#[ type
+  NbJsFromCode = ref object of NbBlock
+    code: string
+    transformedCode: string
+    putAtTop: bool
+    showCode: bool
+func nbJsFromCodeToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbJsFromCode
+  if blk.showCode:
+    "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
+  else:
+    ""
+nbToHtml.funcs["NbJsFromCode"] = nbJsFromCodeToHtml
+addNbBlockToJson(NbJsFromCode) ]#
+
+newNbBlock(NbJsFromCode):
+  code: string
+  transformedCode: string
+  putAtTop: bool
+  showCode: bool
+  toHtml:
+    if blk.showCode:
+      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
+    else:
+      ""
+
+template jsFromCode*(nb: var Nb, args: varargs[untyped]) =
+  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=transformedCode, putAtTop=false, showCode=false)
+  nb.add blk
+
+template nbJsFromCode*(args: varargs[untyped]) =
+  nb.jsFromCode(args)
+
+#[ type
+  NbJsFromCodeOwnFile = ref object of NbBlock
+    code: string
+    transformedCode: string
+    jsCode: string
+    showCode: bool
+func nbJsFromCodeOwnFileToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbJsFromCodeOwnFile
+  result =
+    if blk.showCode:
+      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
+    else:
+      ""
+  result &= &"<script>\n{blk.jsCode}\n</script>"
+nbToHtml.funcs["NbJsFromCodeOwnFile"] = nbJsFromCodeOwnFileToHtml
+addNbBlockToJson(NbJsFromCodeOwnFile) ]#
+
+newNbBlock(NbJsFromCodeOwnFile):
+  code: string
+  transformedCode: string
+  jsCode: string
+  showCode: bool
+  toHtml:
+    result =
+      if blk.showCode:
+        "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
+      else:
+        ""
+    result &= &"<script>\n{blk.jsCode}\n</script>"
+
+template jsFromCodeOwnFile*(nb: var Nb, args: varargs[untyped]) =
+  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = NbJsFromCodeOwnFile(code: originalCode, transformedCode: transformedCode, showCode: false, kind: "NbJsFromCodeOwnFile")
+  nb.add blk
+
+template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
+  nb.jsFromCodeOwnFile(args)
+
+# jsutils.nim (these currently require to know of NbJsFromCode and NbJsFromCodeOwnFile...)
+proc compileNimToJs*(nb: var Nb, blk: NbBlock): string =
+  let blk = blk.NbJsFromCodeOwnFile
+  let tempdir = getTempDir() / "nimib"
+  createDir(tempdir)
+  let (dir, filename, ext) = (getCurrentDir().AbsoluteDir, "js_file", ".nim")#doc.thisFile.splitFile()
+  let nimfile = dir / (filename & "_nbCodeToJs_" & $nb.doc.newId() & ext).RelativeFile
+  let jsfile = tempdir / &"out{hash(nb.doc.title)}.js"
+  var codeText = blk.transformedCode
+  let nbJsCounter = nb.doc.nbJsCounter
+  nb.doc.nbJsCounter += 1
+  var bumpGensymString = """
+import std/[macros, json]
+
+macro bumpGensym(n: static int) =
+  for i in 0 .. n:
+    let _ = gensym()
+
+"""
+  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
+  codeText = bumpGensymString & codeText
+  writeFile(nimfile, codeText)
+  let kxiname = "nimib_kxi_" & $nb.doc.newId()
+  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
+  if errorCode != 0:
+    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
+  removeFile(nimfile)
+  let jscode = readFile(jsfile)
+  removeFile(jsfile)
+  return jscode
+
+proc nbCollectAllNbJs*(nb: var Nb) =
+  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
+  var code = ""
+  for blk in nb.doc.blocksFlattened:
+    if blk of NbJsFromCode:
+      let blk = blk.NbJsFromCode
+      if blk.putAtTop:
+        topCode.add "\n" & blk.transformedCode
+      else:
+        code.add "\n" & blk.transformedCode
+  code = topCode & "\n" & code
+
+  if not code.isEmptyOrWhitespace:
+    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
+    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
+    nb.add blk
+
+  # loop over all nbJsFromCodeOwnFile and compile them
+  for blk in nb.doc.blocksFlattened:
+    if blk of NbJsFromCodeOwnFile:
+      var blk = blk.NbJsFromCodeOwnFile
+      blk.jsCode = nb.compileNimToJs(blk)
+
+
+when isMainModule:
+  import print
+  nbInit
+  nbDetails("Click for details:"):
+    nbText: "*hi*"
+    nbImage("img.png")
+    nbDetails("go deeper"):
+      nbText("42")
+  nbCode:
+    echo "hi"
+  nb.code:
+    echo "nb.code"
+  nbDetails("Hide js code:"):
+    nbJsFromCode:
+      echo "bye!"
+  nbSave
+  #[
+<!DOCTYPE html>
+<title>a nimib document<title>
+<details><summary>Click for details:</summary>
+<p><em>hi</em></p>
+<img src= 'img.png'>
+<details><summary>go deeper</summary>
+<p>42</p>
+</details>
+</details>
+<pre><code class="nim">
+
+echo "hi"
+</code></pre>
+<pre>
+hi
+
+</pre>
+  ]#
+
+  let docToJson = nb.doc.toJson()
+  print docToJson
+  let docFromJson = docToJson.fromJson(NbDoc) # but now this fails
+  print docFromJson
+  print docFromJson.blocks[0].NbDetails
+  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
+  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
+  print docFromJson.blocks[1].NbCode
+  print docFromJson.blocks[2].NbCode
+  print docFromJson.blocks[3].NbDetails.blocks[0].NbJsFromCode
+  print docFromJson.blocks[4].NbJsFromCodeOwnFile
+  #[
+  docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
+docFromJson=NbDoc:ObjectType(
+  title: "a nimib document",
+  blocks: @[NbBlock:ObjectType(kind: "NbDetails"), NbBlock:ObjectType(kind: "NbCode")],
+  kind: "NbDoc"
+)
+docFromJson.blocks[0].NbDetails=NbDetails:ObjectType(
+  summary: "Click for details:",
+  blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage"), NbBlock:ObjectType(kind: "NbDetails")],
+  kind: "NbDetails"
+)
+docFromJson.blocks[0].NbDetails.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
+docFromJson.blocks[0].NbDetails.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage")
+docFromJson.blocks[1].NbCode=NbCode:ObjectType(code: "\necho "hi"", output: "hi\n", lang: "nim", kind: "NbCode")
+  ]#
+

From 9394c20293b5af0b7280cfa144d92556ed86ee32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Wed, 19 Feb 2025 20:59:52 +0100
Subject: [PATCH 30/73] start the chaotic work of rewriting nimib

---
 sandbox/minib/minib.nim   |   2 +-
 src/nimib.nim             |  90 ++++++++++++--------
 src/nimib/blocks.nim      |  23 ++++-
 src/nimib/docs.nim        |   8 +-
 src/nimib/globals.nim     |   4 +
 src/nimib/jsons.nim       |  37 +++++++++
 src/nimib/jsutils.nim     |  85 ++++++++++++++++++-
 src/nimib/nimibSugars.nim | 133 +++++++++++++++++++++++++++++
 src/nimib/renders.nim     |  19 +++--
 src/nimib/themes.nim      | 171 ++++++++++++++++++++++++++++++--------
 src/nimib/types.nim       |  49 +++++++----
 11 files changed, 517 insertions(+), 104 deletions(-)
 create mode 100644 src/nimib/globals.nim
 create mode 100644 src/nimib/jsons.nim
 create mode 100644 src/nimib/nimibSugars.nim

diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
index d1feb5e..316750d 100644
--- a/sandbox/minib/minib.nim
+++ b/sandbox/minib/minib.nim
@@ -265,7 +265,7 @@ template nbSave* =
 # nbToHtml.funcs["NbText"] = nbTextToHtml
 # addNbBlockToJson(NbText)
 
-newNbBlock(nbText):
+newNbBlock(NbText):
   text: string
   toHtml:
     {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
diff --git a/src/nimib.nim b/src/nimib.nim
index b2be22e..55ed5ef 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -1,7 +1,9 @@
-import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, jsonutils]
+import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
+import std / jsonutils except toJson
 export jsonutils
-import nimib / [types, blocks, docs, boost, config, options, capture, jsutils]
-export types, blocks, docs, boost, sugar, jsutils
+import markdown
+import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars] 
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -15,48 +17,49 @@ export searchTable, searchDirs, castStr
 template moduleAvailable*(module: untyped): bool =
   (compiles do: import module)
 
-template nbInit*(theme = themes.useDefault, backend = renders.useHtmlBackend, thisFileRel = "") =
-  var nb {.inject.}: NbDoc
-  nb.initDir = getCurrentDir().AbsoluteDir
-  loadOptions nb
-  loadCfg nb
+template nbInit*(theme = themes.useDefault, renderer: NbRender = nbToHtml, thisFileRel = "") =
+  var nb {.inject.}: Nb
+  nb.doc = NbDoc(kind: "NbDoc")
+  nb.doc.initDir = getCurrentDir().AbsoluteDir
+  loadOptions nb.doc
+  loadCfg nb.doc
 
   # nbInit can be called not from inside the correct file (e.g. when rendering markdown files in nimibook)
   if thisFileRel == "":
-    nb.thisFile = instantiationInfo(-1, true).filename.AbsoluteFile
+    nb.doc.thisFile = instantiationInfo(-1, true).filename.AbsoluteFile
   else:
-    nb.thisFile = nb.srcDir / thisFileRel.RelativeFile
-    echo "[nimib] thisFile: ", nb.thisFile
+    nb.doc.thisFile = nb.doc.srcDir / thisFileRel.RelativeFile
+    echo "[nimib] thisFile: ", nb.doc.thisFile
 
   try:
-    nb.source = read(nb.thisFile)
+    nb.doc.source = read(nb.doc.thisFile)
   except IOError:
     echo "[nimib] cannot read source"
 
-  if nb.options.filename == "":
-    nb.filename = nb.thisFile.string.splitFile.name & ".html"
+  if nb.doc.options.filename == "":
+    nb.doc.filename = nb.doc.thisFile.string.splitFile.name & ".html"
   else:
-    nb.filename = nb.options.filename
+    nb.doc.filename = nb.doc.options.filename
 
-  if nb.cfg.srcDir != "":
-    echo "[nimib] srcDir: ", nb.srcDir
-    nb.filename = (nb.thisDir.relativeTo nb.srcDir).string / nb.filename
-    echo "[nimib] filename: ", nb.filename
+  if nb.doc.cfg.srcDir != "":
+    echo "[nimib] srcDir: ", nb.doc.srcDir
+    nb.doc.filename = (nb.doc.thisDir.relativeTo nb.doc.srcDir).string / nb.doc.filename
+    echo "[nimib] filename: ", nb.doc.filename
 
-  if nb.cfg.homeDir != "":
-    echo "[nimib] setting current directory to nb.homeDir: ", nb.homeDir
-    setCurrentDir nb.homeDir
+  if nb.doc.cfg.homeDir != "":
+    echo "[nimib] setting current directory to nb.doc.homeDir: ", nb.doc.homeDir
+    setCurrentDir nb.doc.homeDir
 
   # can be overriden by theme, but it is better to initialize this anyway
-  nb.templateDirs = @["./", "./templates/"]
-  nb.partials = initTable[string, string]()
-  nb.context = newContext(searchDirs = @[]) # templateDirs and partials added during nbSave
+  #nb.templateDirs = @["./", "./templates/"]
+  #nb.partials = initTable[string, string]()
+  nb.doc.context = newJObject() #newContext(searchDirs = @[]) # templateDirs and partials added during nbSave
 
   # apply render backend (default backend can be overriden by theme)
-  backend nb
+  nb.backend = renderer
 
   # apply theme
-  theme nb
+  theme nb.doc # how do we handle themes?
 
 template nbInitMd*(thisFileRel = "") = 
   var tfr = if thisFileRel == "":
@@ -102,9 +105,25 @@ template nimibCode*(body: untyped) =
     discard
   body
 
-template nbText*(text: string) =
+#[ template nbText*(text: string) =
   newNbSlimBlock("nbText"):
-    nb.blk.output = text
+    nb.blk.output = text ]#
+
+newNbBlock(NbText):
+  text: string
+  toHtml:
+    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+      markdown(blk.text, config=initGfmConfig())
+
+proc text*(nb: var Nb, text: string) =
+  let blk = newNbText(text=text)
+  nb.add blk
+
+template nbText*(ttext: string) =
+  nb.text(ttext)
+
+
+
 
 template nbTextWithCode*(body: untyped) =
   newNbCodeBlock("nbText", body):
@@ -264,21 +283,22 @@ template nbSave* =
   #   - in case you need to manage additional exceptions for a specific document add a new set of partials before calling nbSave
   nb.nbCollectAllNbJs()
 
-  nb.context.searchDirs(nb.templateDirs)
-  nb.context.searchTable(nb.partials)
+  echo "nb.doc.blocks: ", nb.doc.blocks
+  #nb.context.searchDirs(nb.templateDirs)
+  #nb.context.searchTable(nb.partials)
 
   write nb
-  if nb.options.show:
-    open nb
+  if nb.doc.options.show:
+    open nb.doc
 
 # how to change this to a better version using nb?
 template relPath*(path: AbsoluteFile | AbsoluteDir): string =
   (path.relativeTo nb.homeDir).string
 
 # aliases to minimize breaking changes after refactoring nbDoc -> nb. Should be deprecated at some point?
-template nbDoc*: NbDoc = nb
+#[ template nbDoc*: NbDoc = nb
 template nbBlock*: NbBlock = nb.blk
-template nbHomeDir*: AbsoluteDir = nb.homeDir
+template nbHomeDir*: AbsoluteDir = nb.homeDir ]#
 
 # use --nbShow runtime option instead of this
 template nbShow* =
diff --git a/src/nimib/blocks.nim b/src/nimib/blocks.nim
index 7ba5665..3b92254 100644
--- a/src/nimib/blocks.nim
+++ b/src/nimib/blocks.nim
@@ -16,7 +16,28 @@ func nbNormalize*(text: string): string =
   text.replace("\c\l", "\n").replace("\c", "\n").strip # this could be made more efficient
 # note that: '\c' == '\r' and '\l' == '\n'
 
-template newNbBlock*(cmd: string, readCode: static[bool], nbDoc, nbBlock, body, blockImpl: untyped) =
+proc add*(nb: var Nb, blk: NbBlock) =
+  nb.blk = blk
+  if nb.containers.len == 0:
+    nb.doc.blocks.add blk
+  else:
+    nb.containers[^1].blocks.add blk
+
+template withContainer*(nb: var Nb, container: NbContainer, body: untyped) =
+  nb.add container
+  nb.containers.add container
+  body
+  discard nb.containers.pop
+
+func blocksFlattened*(doc: NbContainer): seq[NbBlock] =
+  for blk in doc.blocks:
+    result.add blk
+    if blk of NbContainer:
+      result.add blk.NbContainer.blocksFlattened()
+
+# do we need this anymore? How do we implement something similar now? I'm thinking mainly of the logging
+# insert it into the newBlockName procs?
+template newNbBlockOld*(cmd: string, readCode: static[bool], nbDoc, nbBlock, body, blockImpl: untyped) =
   stdout.write "[nimib] ", nbDoc.blocks.len, " ", cmd, ": "
   nbBlock = NbBlock(command: cmd, context: newContext(searchDirs = @[], partials = nbDoc.partials))
   when readCode:
diff --git a/src/nimib/docs.nim b/src/nimib/docs.nim
index d1b5a85..81d1676 100644
--- a/src/nimib/docs.nim
+++ b/src/nimib/docs.nim
@@ -3,14 +3,14 @@ import browsers
 import types
 import nimib / renders
 
-proc write*(doc: var NbDoc) =
+proc write*(nb: Nb) =
   echo "[nimib] current directory: ", getCurrentDir()
-  let dir = doc.filename.splitFile().dir
+  let dir = nb.doc.filename.splitFile().dir
   if not dir.dirExists:
     echo "[nimib] creating directory: ", dir
     createDir(dir)
-  echo "[nimib] saving file: ", doc.filename
-  writeFile(doc.filename, render(doc))
+  echo "[nimib] saving file: ", nb.doc.filename
+  writeFile(nb.doc.filename, nb.render(nb.doc))
 
 proc open*(doc: NbDoc) =
   openDefaultBrowser(doc.filename)
diff --git a/src/nimib/globals.nim b/src/nimib/globals.nim
new file mode 100644
index 0000000..15ee10f
--- /dev/null
+++ b/src/nimib/globals.nim
@@ -0,0 +1,4 @@
+import ./types
+
+var nbToJson*: Table[string, proc (s: string, i: var int): NbBlock]
+var nbToHtml* = NbRender() # since we need it for json, let's make it also for html
\ No newline at end of file
diff --git a/src/nimib/jsons.nim b/src/nimib/jsons.nim
new file mode 100644
index 0000000..5afcfe0
--- /dev/null
+++ b/src/nimib/jsons.nim
@@ -0,0 +1,37 @@
+import jsony
+import ./types, ./globals
+export jsony
+
+template addNbBlockToJson*(kind: untyped) =
+  nbToJson[$kind] =
+    proc (s: string, i: var int): NbBlock =
+      var v: kind
+      new v
+      parseHook(s, i, v[])
+      result = v
+
+  method dump*(n: kind): string =
+    jsony.toJson(n[])
+
+proc parseHook*(s: string, i: var int, v: var NbBlock) =
+  # First parse the typename
+  var n: NbBlock = NbBlock()
+  let current_i = i
+  parseHook(s, i, n[])
+  # Reset i
+  i = current_i
+  # Parse the correct type
+  let kind = n.kind
+  if kind notIn nbToJson:
+    raise ValueError.newException "cannot find kind in nbToJson: \"" & kind & '"' 
+  v = nbToJson[kind](s, i)
+
+method dump*(n: NbBlock): string {.base.} =
+    jsony.toJson(n[])
+
+proc dumpHook*(s: var string, v: NbBlock) =
+  s.add v.dump()
+
+template dumpKey*(s: var string, v: string) =
+  const v2 = jsony.toJson(v) & ":"
+  s.add v2
diff --git a/src/nimib/jsutils.nim b/src/nimib/jsutils.nim
index 5e7d032..aaff0fb 100644
--- a/src/nimib/jsutils.nim
+++ b/src/nimib/jsutils.nim
@@ -1,5 +1,30 @@
 import std / [macros, macrocache, tables, strutils, strformat, sequtils, sugar, os, hashes]
-import ./types
+import ./types, ./nimibSugars, ./globals, ./jsons, ./blocks
+
+
+newNbBlock(NbJsFromCode):
+  code: string
+  transformedCode: string
+  putAtTop: bool
+  showCode: bool
+  toHtml:
+    if blk.showCode:
+      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
+    else:
+      ""
+
+newNbBlock(NbJsFromCodeOwnFile):
+  code: string
+  transformedCode: string
+  jsCode: string
+  showCode: bool
+  toHtml:
+    result =
+      if blk.showCode:
+        "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
+      else:
+        ""
+    result &= &"<script>\n{blk.jsCode}\n</script>"
 
 proc contains(tab: CacheTable, keyToCheck: string): bool =
   for key, val in tab:
@@ -179,7 +204,8 @@ macro nbHappyxCodeBackend*(rootId: untyped, args: varargs[untyped]) =
   let call = newCall(ident"nbJsFromCodeOwnFile", callArgs)
   result = call
 
-proc compileNimToJs*(doc: var NbDoc, blk: var NbBlock) =
+#[ proc compileNimToJs*(doc: var NbDoc, blk: var NbBlock) =
+  let blk = 
   let tempdir = getTempDir() / "nimib"
   createDir(tempdir)
   let (dir, filename, ext) = doc.thisFile.splitFile()
@@ -225,4 +251,57 @@ proc nbCollectAllNbJs*(doc: var NbDoc) =
     var blk = NbBlock(command: "nbJsFromCodeOwnFile", code: code, context: newContext(searchDirs = @[], partials = doc.partials), output: "")
     blk.context["transformedCode"] = code
     doc.blocks.add blk
-    doc.blk = blk
+    doc.blk = blk ]#
+
+proc compileNimToJs*(nb: var Nb, blk: NbBlock): string =
+  let blk = blk.NbJsFromCodeOwnFile
+  let tempdir = getTempDir() / "nimib"
+  createDir(tempdir)
+  let (dir, filename, ext) = (getCurrentDir().AbsoluteDir, "js_file", ".nim")#doc.thisFile.splitFile()
+  let nimfile = dir / (filename & "_nbCodeToJs_" & $nb.doc.newId() & ext).RelativeFile
+  let jsfile = tempdir / &"out{hash(nb.doc.thisFile)}.js"
+  var codeText = blk.transformedCode
+  let nbJsCounter = nb.doc.nbJsCounter
+  nb.doc.nbJsCounter += 1
+  var bumpGensymString = """
+import std/[macros, json]
+
+macro bumpGensym(n: static int) =
+  for i in 0 .. n:
+    let _ = gensym()
+
+"""
+  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
+  codeText = bumpGensymString & codeText
+  writeFile(nimfile, codeText)
+  let kxiname = "nimib_kxi_" & $nb.doc.newId()
+  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
+  if errorCode != 0:
+    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
+  removeFile(nimfile)
+  let jscode = readFile(jsfile)
+  removeFile(jsfile)
+  return jscode
+
+proc nbCollectAllNbJs*(nb: var Nb) =
+  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
+  var code = ""
+  for blk in nb.doc.blocksFlattened:
+    if blk of NbJsFromCode:
+      let blk = blk.NbJsFromCode
+      if blk.putAtTop:
+        topCode.add "\n" & blk.transformedCode
+      else:
+        code.add "\n" & blk.transformedCode
+  code = topCode & "\n" & code
+
+  if not code.isEmptyOrWhitespace:
+    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
+    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
+    nb.add blk
+
+  # loop over all nbJsFromCodeOwnFile and compile them
+  for blk in nb.doc.blocksFlattened:
+    if blk of NbJsFromCodeOwnFile:
+      var blk = blk.NbJsFromCodeOwnFile
+      blk.jsCode = nb.compileNimToJs(blk)
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
new file mode 100644
index 0000000..5236660
--- /dev/null
+++ b/src/nimib/nimibSugars.nim
@@ -0,0 +1,133 @@
+import std / [macros, strutils, sequtils, genasts]
+
+proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
+  n.expectKind nnkCall
+  (n[0].strVal, n[1][0])
+
+macro newNbBlock*(typeName: untyped, body: untyped): untyped =
+  # typeName is either `ident` or
+  # Infix
+  #   Ident "of"
+  #   Ident "nbImage"
+  #   Ident "NbBlock"
+
+  let (typeNameStr, parentType) =
+   if typeName.kind == nnkIdent:
+     (typeName.strVal, "NbBlock".ident)
+   else:
+     (typeName[1].strVal, typeName[2])
+
+  let capitalizedTypeName = typeNameStr.capitalizeAscii
+  let lowercasedTypeName = typeNameStr.toLower
+
+  # body is:
+  # StmtList
+  #   Call
+  #     Ident "url"
+  #     StmtList
+  #       Ident "string"
+  #   Call
+  #     Ident "burl"
+  #     StmtList
+  #       Asgn
+  #         Ident "int"
+  #         IntLit 1
+  #   Call
+  #     Ident "toHtml"
+  #     StmtList
+  #       DotExpr
+  #         Ident "blk"
+  #         Ident "url"
+
+  echo "Body:\n", body.treeRepr
+
+  var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
+  var toHtmlBody: NimNode
+  body.expectKind(nnkStmtList)
+  for n in body:
+    let (name, body) = n.parseCallStmt()
+    if eqIdent(name, "toHtml"):
+      toHtmlBody = body
+    else:
+      fields.add (name, body)
+
+  var fieldsList = nnkRecList.newTree()
+  for (fName, fType) in fields:
+    fieldsList.add newIdentDefs(fName.ident, fType)
+  let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
+    postfix(capitalizedTypeName.ident, "*"),
+    newEmptyNode(), # generic
+    nnkRefTy.newTree(
+      nnkObjectTy.newTree(
+        newEmptyNode(), # pragma
+        nnkOfInherit.newTree(
+          parentType
+        ),
+        fieldsList
+      )
+    )
+  ))
+
+  echo "Type:\n", typeDefinition.repr
+
+  # Next: generate initializer with prefilled kind
+  # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
+  # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
+
+  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
+  var objectConstructor = nnkObjConstr.newTree(
+    capitalizedTypeName.ident
+  )
+  objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
+  for (fName, _) in fields:
+    objectConstructor.add newColonExpr(fName.ident, fName.ident)
+  var procBody = newStmtList(objectConstructor)
+
+  var procName = postfix(ident("new" & capitalizedTypeName), "*")
+  let initializer = newProc(procName, procParams, procBody)
+
+  echo "init:\n", initializer.repr
+
+  # Next: generate nbImageToHtml from toHtmlBody
+  let renderProcName = (lowercasedTypeName & "ToHtml").ident
+  let renderProc = genAst(name = renderProcName, body = toHtmlBody, blk = ident"blk", nb = ident"nb", typeName=capitalizedTypeName.ident):
+    proc name*(blk: NbBlock, nb: Nb): string =
+      let blk = typeName(blk)
+      body
+
+
+  # Next: generate these lines:
+  # nbToHtml.funcs["NbImage"] = nbImageToHtml
+  # addNbBlockToJson(NbImage)
+  # should we make this into a proc instead so it can be used in the non-sugar variant as well?
+  let hookAssignements = genAst(key = capitalizedTypeName.newLit, f = renderProcName, typeName = capitalizedTypeName.ident):
+    nbToHtml.funcs[key] = f
+    addNbBlockToJson(typeName)
+
+  result = newStmtList(
+    typeDefinition,
+    initializer,
+    renderProc,
+    hookAssignements
+  )
+
+  echo result.repr
+
+  #assert false
+
+macro withNewlines*(body: untyped) : string =
+  body.expectKind nnkStmtList
+  result = infix(body[0], "&", "\n".newLit)
+  if body.len > 1:
+    for line in body[1..^1]:
+      # TODO: handle for loops
+      # if it's an if-statement, check if it has an else-clause. Otherwise add one which returns ""
+      if line.kind == nnkIfStmt and line.findChild(it.kind == nnkElse).isNil:
+        line.add nnkElse.newTree("".newLit)
+      result = infix(result, "&", line)
+      result = infix(result, "&", "\n".newLit)
+  #echo result.treerepr
+  #echo result.repr
+
+  
+
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index cbcd9b7..10337dd 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -1,18 +1,24 @@
 import std / [strutils, tables, sugar, os, strformat, sequtils]
-import ./types, ./jsutils, markdown, mustache
+import ./types, markdown, mustache # ./jsutils,
 
 import highlight
 import mustachepkg/values
 
-proc mdOutputToHtml(doc: var NbDoc, blk: var NbBlock) =
+#[ proc mdOutputToHtml(doc: var NbDoc, blk: var NbBlock) =
   blk.context["outputToHtml"] = markdown(blk.output, config=initGfmConfig()).dup(removeSuffix)
 
 proc highlightCode(doc: var NbDoc, blk: var NbBlock) =
-  blk.context["codeHighlighted"] = highlightNim(blk.code)
+  blk.context["codeHighlighted"] = highlightNim(blk.code) ]#
 
+func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbContainer
+  for b in blk.blocks:
+    result.add nb.render(b).strip & '\n'
+  result.strip
 
 proc useHtmlBackend*(doc: var NbDoc) =
-  doc.partials["nbText"] = "{{&outputToHtml}}"
+  discard
+#[   doc.partials["nbText"] = "{{&outputToHtml}}"
   doc.partials["nbCode"] = """
 {{>nbCodeSource}}
 {{>nbCodeOutput}}"""
@@ -54,9 +60,9 @@ proc useHtmlBackend*(doc: var NbDoc) =
   doc.renderProcs = initTable[string, NbRenderProc]()
   doc.renderProcs["mdOutputToHtml"] = mdOutputToHtml
   doc.renderProcs["highlightCode"] = highlightCode
-  doc.renderProcs["compileNimToJs"] = compileNimToJs
+  doc.renderProcs["compileNimToJs"] = compileNimToJs ]#
 
-proc useMdBackend*(doc: var NbDoc) =
+#[ proc useMdBackend*(doc: var NbDoc) =
   doc.partials["document"] = """
 {{#blocks}}
 
@@ -132,3 +138,4 @@ proc render*(nb: var NbDoc): string =
     blocks.add nb.render(blk)
   nb.context["blocks"] = blocks
   return "{{> document}}".render(nb.context)
+ ]#
\ No newline at end of file
diff --git a/src/nimib/themes.nim b/src/nimib/themes.nim
index 94db567..2a6b7b4 100644
--- a/src/nimib/themes.nim
+++ b/src/nimib/themes.nim
@@ -1,6 +1,109 @@
-from mustachepkg/values import castStr
-import types, gits, highlight, config
+#from mustachepkg/values import castStr
+import std/[json, macros, sequtils, strutils, strformat]
+import types, gits, highlight, config, jsons, globals, nimibSugars
 
+
+func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbContainer
+  for b in blk.blocks.items:
+    result.add nb.render(b).strip & '\n'
+  result.strip
+# should I add this to the global object?
+
+# github light svg adapted from: https://iconify.design/icon-sets/octicon/mark-github.html
+# github dark svg taken directly from github website
+const githubLogoLight* = """<svg aria-hidden="true" width="1.2em" height="1.2em" style="vertical-align: middle;" preserveAspectRatio="xMidYMid meet" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59c.4.07.55-.17.55-.38c0-.19-.01-.82-.01-1.49c-2.01.37-2.53-.49-2.69-.94c-.09-.23-.48-.94-.82-1.13c-.28-.15-.68-.52-.01-.53c.63-.01 1.08.58 1.23.82c.72 1.21 1.87.87 2.33.66c.07-.52.28-.87.51-1.07c-1.78-.2-3.64-.89-3.64-3.95c0-.87.31-1.59.82-2.15c-.08-.2-.36-1.02.08-2.12c0 0 .67-.21 2.2.82c.64-.18 1.32-.27 2-.27c.68 0 1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82c.44 1.1.16 1.92.08 2.12c.51.56.82 1.27.82 2.15c0 3.07-1.87 3.75-3.65 3.95c.29.25.54.73.54 1.48c0 1.07-.01 1.93-.01 2.2c0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z" fill="#000"></path></svg>"""
+const githubLogoDark* = """<svg aria-hidden="true" width="1.2em" height="1.2em" style="vertical-align: middle; fill: #fff" preserveAspectRatio="xMidYMid meet" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg>"""
+
+func getTitle*(doc: NbDoc): string =
+  doc.context{"title"}.getStr("nimib document")
+
+
+# All of this should be moved to renders.nim?
+func headToHtml*(doc: NbDoc): string =
+  result = withNewlines:
+    fmt"""
+<head>
+  <title>{doc.getTitle}</title>
+  <meta content="text/html; charset=utf-8" http-equiv="content-type">
+  <meta content="width=device-width, initial-scale=1" name="viewport">
+  <meta content="nimib {doc.context.getOrDefault("version").getStr}" name="generator">
+  {doc.context.getOrDefault("stylesheet").getStr}
+  {doc.context.getOrDefault("highlight").getStr}
+  {doc.context.getOrDefault("nb_style").getStr}
+  {doc.context.getOrDefault("latex").getStr}
+    """
+    if not doc.context{"disableHighlightJs"}.getBool(false):
+      doc.context{"highlightJs"}.getStr
+    "</head>"
+    
+
+
+
+func madeWithNimibToHtml*(): string =
+  """<span class="nb-small">made with <a href="https://pietroppeter.github.io/nimib/">nimib 🐳</a></span>"""
+
+func homeLinkToHtml*(homePath: string): string =
+  fmt"""<a href="{homePath}">🏡</a>"""
+
+func headerLeftToHtml*(doc: NbDoc): string =
+  homeLinkToHtml(doc.context{"path_to_root"}.getStr("/"))
+
+func headerCenterToHtml*(doc: NbDoc): string =
+  let title = doc.getTitle()
+  fmt"<code>{title}</code>"
+
+func headerRightToHtml*(doc: NbDoc): string =
+  if not isNil(doc.context{"github_remote_url"}):
+    let githubRemoteUrl = doc.context{"github_remote_url"}.getStr
+    let githubLogo = doc.context{"github_logo"}.getStr(githubLogoLight)
+    result = fmt"""<a href="{github_remote_url}">{github_logo}</a>"""
+
+func headerToHtml*(doc: NbDoc): string =
+  result = withNewlines:
+    "<header>"
+    """<div class="nb-box">"""
+    " <span>" & headerLeftToHtml(doc) & "</span>"
+    " <span>" & headerCenterToHtml(doc) & "</span>"
+    " <span>" & headerRightToHtml(doc) & "</span>"
+    "</div>"
+    "<hr>"
+    "</header>"
+
+func leftToHtml*(): string =
+  ""
+
+func mainToHtml*(blk: NbBlock, nb: Nb): string =
+  result = withNewlines:
+    "<main>"
+    nbContainerToHtml(blk, nb)
+    "</main>"
+
+func rightToHtml*(): string =
+  ""
+
+func footerToHtml*(): string =
+  ""
+
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbDoc
+  result = withNewlines:
+    "<!DOCTYPE html>"
+    """<html lang="en-us">"""
+    headToHtml(blk)
+    "<body>"
+    headerToHtml(blk)
+    leftToHtml()
+    mainToHtml(blk, nb)
+    rightToHtml()
+    footerToHtml()
+    "</body>"
+  # TODO: Convert all constants below into functions with inputs!
+
+addNbBlockToJson(NbDoc) # should this be here? Probably not!
+nbToHtml.funcs["NbDoc"] = nbDocToHtml
+
+# TODO: Make these old partials into procs with inputs so they can be reused!
 const document* = """
 <!DOCTYPE html>
 <html lang="en-us">
@@ -97,10 +200,6 @@ const header* = """
 </header>"""
 const homeLink* = """<a href="{{path_to_root}}">🏡</a>"""
 const githubLink* = """<a href="{{github_remote_url}}">{{{github_logo}}}</a>"""
-# github light svg adapted from: https://iconify.design/icon-sets/octicon/mark-github.html
-# github dark svg taken directly from github website
-const githubLogoLight* = """<svg aria-hidden="true" width="1.2em" height="1.2em" style="vertical-align: middle;" preserveAspectRatio="xMidYMid meet" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59c.4.07.55-.17.55-.38c0-.19-.01-.82-.01-1.49c-2.01.37-2.53-.49-2.69-.94c-.09-.23-.48-.94-.82-1.13c-.28-.15-.68-.52-.01-.53c.63-.01 1.08.58 1.23.82c.72 1.21 1.87.87 2.33.66c.07-.52.28-.87.51-1.07c-1.78-.2-3.64-.89-3.64-3.95c0-.87.31-1.59.82-2.15c-.08-.2-.36-1.02.08-2.12c0 0 .67-.21 2.2.82c.64-.18 1.32-.27 2-.27c.68 0 1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82c.44 1.1.16 1.92.08 2.12c.51.56.82 1.27.82 2.15c0 3.07-1.87 3.75-3.65 3.95c.29.25.54.73.54 1.48c0 1.07-.01 1.93-.01 2.2c0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z" fill="#000"></path></svg>"""
-const githubLogoDark* = """<svg aria-hidden="true" width="1.2em" height="1.2em" style="vertical-align: middle; fill: #fff" preserveAspectRatio="xMidYMid meet" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"></path></svg>"""
 
 const footer* = """
 <footer>
@@ -135,51 +234,51 @@ proc optOut*(content, keyword: string): string =
   "{{^" & keyword & "}}" & content & "{{/" & keyword & "}}"
 
 proc useDefault*(doc: var NbDoc) =
-  doc.context["path_to_root"] = (doc.srcDirRel).string
-  doc.context["path_to_here"] = (doc.thisFileRel).string
-  doc.context["source"] = doc.source
+  doc.context["path_to_root"] = %(doc.srcDirRel).string
+  doc.context["path_to_here"] = %(doc.thisFileRel).string
+  doc.context["source"] = %doc.source
 
-  doc.partials["document"] = document
-  doc.partials["main"] = main
+  #doc.partials["document"] = document
+  #doc.partials["main"] = main
   # head
-  doc.partials["head"] = head
-  doc.context["version"] = getNimibVersion()
-  doc.context["favicon"] = faviconWhale
-  doc.context["stylesheet"] = waterLight
-  doc.context["highlight"] = atomOneLight
-  doc.context["highlightJs"] = highlightJsTags
-  doc.context["nb_style"] = nbStyle
+  #doc.partials["head"] = head
+  doc.context["version"] = %getNimibVersion()
+  doc.context["favicon"] = %faviconWhale
+  doc.context["stylesheet"] = %waterLight
+  doc.context["highlight"] = %atomOneLight
+  doc.context["highlightJs"] = %highlightJsTags
+  doc.context["nb_style"] = %nbStyle
   # header
-  doc.partials["header"] = header
-  doc.partials["header_left"] = homeLink
+  #doc.partials["header"] = header
+  #doc.partials["header_left"] = homeLink
   doc.context["title"] = doc.context["path_to_here"]
-  doc.partials["header_center"] = "<code>" & doc.context["title"].castStr & "</code>"
+  #doc.partials["header_center"] = "<code>" & doc.context["title"].castStr & "</code>"
   if isGitAvailable() and isOnGithub():
-    doc.partials["header_right"] = githubLink
-    doc.context["github_remote_url"] = getGitRemoteUrl()
-    doc.context["github_logo"] = githubLogoLight
+    #doc.partials["header_right"] = githubLink
+    doc.context["github_remote_url"] = %getGitRemoteUrl()
+    doc.context["github_logo"] = %githubLogoLight
   # footer
-  doc.partials["footer"] = footer
-  doc.partials["footer_left"] = madeWithNimib
-  doc.partials["footer_right"] = optOut(showSourceButton, "no_source")
-  doc.partials["source_section"] = optOut(sourceSection, "no_source")
-  doc.partials["show_source_script"] = optOut(showSourceScript, "no_source")
-  doc.context["source_highlighted"] = highlightNim(doc.context["source"].castStr)
+  # doc.partials["footer"] = footer
+  # doc.partials["footer_left"] = madeWithNimib
+  # doc.partials["footer_right"] = optOut(showSourceButton, "no_source")
+  # doc.partials["source_section"] = optOut(sourceSection, "no_source")
+  # doc.partials["show_source_script"] = optOut(showSourceScript, "no_source")
+  doc.context["source_highlighted"] = %highlightNim(doc.context["source"].getStr)
 
 proc darkMode*(doc: var NbDoc) =
-  doc.context["stylesheet"] = waterDark
-  doc.context["github_logo"] = githubLogoDark
-  doc.context["highlight"] = androidStudio
+  doc.context["stylesheet"] = %waterDark
+  doc.context["github_logo"] = %githubLogoDark
+  doc.context["highlight"] = %androidStudio
 
 proc useLatex*(doc: var NbDoc) =
-  doc.context["latex"] = latex
+  doc.context["latex"] = %latex
 
 proc disableHighlightJs*(doc: var NbDoc) =
-  doc.context["disableHighlightJs"] = true
+  doc.context["disableHighlightJs"] = %true
 
 proc `title=`*(doc: var NbDoc, text: string) =
   # to deprecate?
-  doc.context["title"] = text
+  doc.context["title"] = %text
 
 proc noTheme*(doc: var NbDoc) =
   discard
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index a3c3192..b6f598f 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -1,13 +1,10 @@
 import mustache, std / tables, nimib / paths, std / parseopt
 export mustache, tables, paths
-import std / [os]
+import std / [os, json]
 
 type
-  NbBlock* = ref object
-    command*: string
-    code*: string
-    output*: string
-    context*: Context
+  NbBlock* = ref object of RootObj
+    kind*: string
   NbOptions* = object
     skipCfg*: bool
     cfgName*, srcDir*, homeDir*, filename*: string
@@ -15,8 +12,12 @@ type
     other*: seq[tuple[kind: CmdLineKind; name, value: string]]
   NbConfig* = object
     srcDir*, homeDir*: string
-  NbRenderProc* = proc (doc: var NbDoc, blk: var NbBlock) {. nimcall .}
-  NbDoc* = object
+  NbRenderFunc* = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
+  NbRender* = ref object of RootObj
+    funcs*: Table[string, NbRenderFunc]
+  NbContainer* = ref object of NbBlock
+    blocks*: seq[NbBlock]
+  NbDoc* = ref object of NbContainer
     thisFile*: AbsoluteFile
     filename*: string
     source*: string
@@ -26,15 +27,20 @@ type
     cfg*: NbConfig
     cfgDir*: AbsoluteDir
     rawCfg*: string
-    blk*: NbBlock  ## current block being processed
-    blocks*: seq[NbBlock]
-    context*: Context
-    partials*: Table[string, string]
-    templateDirs*: seq[string]
-    renderPlans*: Table[string, seq[string]]
-    renderProcs*: Table[string, NbRenderProc]
-    id: int
-    nbJsCounter*: int 
+    context*: JsonNode
+    id*: int
+    nbJsCounter*: int
+  Nb* = object
+    # TODO: which fields should be moved from NbDoc to Nb?
+    # As little as possible?
+    # NbDoc should contain all info relevant to rendering the page and
+    # Nb should just contain stuff needed for producing the NbDoc (like id and nbJsCounter)
+    blk*: NbBlock # last block processed
+    doc*: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
+    containers*: seq[NbContainer] # current container
+    backend*: NbRender # current backend
+
+proc `$`*(blk: NbBlock): string  = $blk[]
 
 proc thisDir*(doc: NbDoc): AbsoluteDir = doc.thisFile.splitFile.dir
 proc srcDir*(doc: NbDoc): AbsoluteDir =
@@ -52,4 +58,11 @@ proc srcDirRel*(doc: NbDoc): RelativeDir = doc.srcDir.relativeTo doc.thisDir
 proc newId*(doc: var NbDoc): int =
   ## Provides a unique integer each time it is called
   result = doc.id
-  inc doc.id
\ No newline at end of file
+  inc doc.id
+
+func render*(nb: Nb, blk: NbBlock): string =
+  debugecho "REndering block: ", blk[]
+  if blk.kind in nb.backend.funcs:
+    nb.backend.funcs[blk.kind](blk, nb)
+  else:
+    ""
\ No newline at end of file

From a23d1edc95c02e4f762278f3c5de0f7430356e77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Thu, 20 Feb 2025 21:28:37 +0100
Subject: [PATCH 31/73] finish theme-related funcs

---
 src/nimib/renders.nim | 28 +++++++++++----
 src/nimib/sources.nim | 10 +++---
 src/nimib/themes.nim  | 84 ++++++++++++++++++++++++++-----------------
 src/nimib/types.nim   | 10 ++++--
 4 files changed, 86 insertions(+), 46 deletions(-)

diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index 10337dd..1d157c1 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -1,5 +1,5 @@
-import std / [strutils, tables, sugar, os, strformat, sequtils]
-import ./types, markdown, mustache # ./jsutils,
+import std / [strutils, tables, sugar, os, strformat, sequtils, json]
+import ./types, markdown, mustache, ./jsutils, ./nimibSugars, ./themes, ./globals, ./jsons
 
 import highlight
 import mustachepkg/values
@@ -10,11 +10,25 @@ import mustachepkg/values
 proc highlightCode(doc: var NbDoc, blk: var NbBlock) =
   blk.context["codeHighlighted"] = highlightNim(blk.code) ]#
 
-func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbContainer
-  for b in blk.blocks:
-    result.add nb.render(b).strip & '\n'
-  result.strip
+func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
+  let doc = blk.NbDoc
+  result = withNewlines:
+    "<!DOCTYPE html>"
+    """<html lang="en-us">"""
+    headToHtml(doc)
+    "<body>"
+    headerToHtml(doc)
+    leftToHtml()
+    mainToHtml(doc, nb)
+    rightToHtml()
+    footerToHtml(doc)
+    "</body>"
+  # TODO: Convert all constants below into functions with inputs!
+
+addNbBlockToJson(NbDoc) # should this be here?
+nbToHtml.funcs["NbDoc"] = nbDocToHtml
+
+
 
 proc useHtmlBackend*(doc: var NbDoc) =
   discard
diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 55ca7d4..30fe972 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -65,7 +65,9 @@ proc finishPos*(node: NimNode): Pos =
         result = toPos(node.lineInfoObj())
 
 proc isCommandLine*(s: string, command: string): bool =
-  nimIdentNormalize(s.strip()).startsWith(nimIdentNormalize(command))
+  # how do we handle nb.code as well as nbCode?
+  # check for contains instead?
+  nimIdentNormalize(s.strip()).startsWith(nimIdentNormalize(command)) or nimIdentNormalize(command) in nimIdentNormalize(s.strip())
 
 proc isCommentLine*(s: string): bool =
   s.strip.startsWith('#')
@@ -155,12 +157,12 @@ macro getCodeAsInSource*(source: string, command: static string, body: untyped):
   let startPosLit = startPos.newLit
 
   result = quote do:
-    if `filename` notin nb.sourceFiles:
-      nb.sourceFiles[`filename`] = readFile(`filename`)
+    if `filename` notin nb.doc.sourceFiles:
+      nb.doc.sourceFiles[`filename`] = readFile(`filename`)
 
     doAssert `endFilename` == `filename`, """
     Code from two different files were found in the same nbCode!
     If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 
     If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example."""
 
-    getCodeBlock(nb.sourceFiles[`filename`], `command`, `startPosLit`, `endPosLit`)
\ No newline at end of file
+    getCodeBlock(nb.doc.sourceFiles[`filename`], `command`, `startPosLit`, `endPosLit`)
\ No newline at end of file
diff --git a/src/nimib/themes.nim b/src/nimib/themes.nim
index 2a6b7b4..a1d6753 100644
--- a/src/nimib/themes.nim
+++ b/src/nimib/themes.nim
@@ -2,14 +2,6 @@
 import std/[json, macros, sequtils, strutils, strformat]
 import types, gits, highlight, config, jsons, globals, nimibSugars
 
-
-func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbContainer
-  for b in blk.blocks.items:
-    result.add nb.render(b).strip & '\n'
-  result.strip
-# should I add this to the global object?
-
 # github light svg adapted from: https://iconify.design/icon-sets/octicon/mark-github.html
 # github dark svg taken directly from github website
 const githubLogoLight* = """<svg aria-hidden="true" width="1.2em" height="1.2em" style="vertical-align: middle;" preserveAspectRatio="xMidYMid meet" viewBox="0 0 16 16"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59c.4.07.55-.17.55-.38c0-.19-.01-.82-.01-1.49c-2.01.37-2.53-.49-2.69-.94c-.09-.23-.48-.94-.82-1.13c-.28-.15-.68-.52-.01-.53c.63-.01 1.08.58 1.23.82c.72 1.21 1.87.87 2.33.66c.07-.52.28-.87.51-1.07c-1.78-.2-3.64-.89-3.64-3.95c0-.87.31-1.59.82-2.15c-.08-.2-.36-1.02.08-2.12c0 0 .67-.21 2.2.82c.64-.18 1.32-.27 2-.27c.68 0 1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82c.44 1.1.16 1.92.08 2.12c.51.56.82 1.27.82 2.15c0 3.07-1.87 3.75-3.65 3.95c.29.25.54.73.54 1.48c0 1.07-.01 1.93-.01 2.2c0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z" fill="#000"></path></svg>"""
@@ -38,8 +30,6 @@ func headToHtml*(doc: NbDoc): string =
     "</head>"
     
 
-
-
 func madeWithNimibToHtml*(): string =
   """<span class="nb-small">made with <a href="https://pietroppeter.github.io/nimib/">nimib 🐳</a></span>"""
 
@@ -82,28 +72,56 @@ func mainToHtml*(blk: NbBlock, nb: Nb): string =
 func rightToHtml*(): string =
   ""
 
-func footerToHtml*(): string =
+func footerLeftToHtml*(): string =
+  madeWithNimibToHtml()
+
+func footerCenterToHtml*(): string =
   ""
 
-func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbDoc
-  result = withNewlines:
-    "<!DOCTYPE html>"
-    """<html lang="en-us">"""
-    headToHtml(blk)
-    "<body>"
-    headerToHtml(blk)
-    leftToHtml()
-    mainToHtml(blk, nb)
-    rightToHtml()
-    footerToHtml()
-    "</body>"
-  # TODO: Convert all constants below into functions with inputs!
-
-addNbBlockToJson(NbDoc) # should this be here? Probably not!
-nbToHtml.funcs["NbDoc"] = nbDocToHtml
-
-# TODO: Make these old partials into procs with inputs so they can be reused!
+func showSourceButtonToHtml*(): string =
+  """<button class="nb-small" id="show" onclick="toggleSourceDisplay()">Show Source</button>"""
+
+func footerRightToHtml*(): string =
+  showSourceButtonToHtml()
+
+func sourceSectionToHtml*(doc: NbDoc): string =
+  fmt"""
+<section id="source">
+<pre><code class="nohighlight nim hljs">{doc.context.getOrDefault("source_highlighted").getStr}</code></pre>
+</section>
+  """
+
+func showSourceScriptToHtml*(): string =
+  """
+<script>
+  function toggleSourceDisplay() {
+    var btn = document.getElementById("show")
+    var source = document.getElementById("source");
+    if (btn.innerHTML=="Show Source") {
+      btn.innerHTML = "Hide Source";
+      source.style.display = "block";
+    } else {
+      btn.innerHTML = "Show Source";
+      source.style.display = "none";
+    }
+  }
+</script>
+  """
+
+func footerToHtml*(doc: NbDoc): string =
+  fmt"""
+<footer>
+<div class="nb-box">
+  <span>{footerLeftToHtml()}</span>
+  <span>{footerCenterToHtml()}</span>
+  <span>{footerRightToHtml()}</span>
+</div>
+</footer>
+{sourceSectionToHtml(doc)}
+{showSourceScriptToHtml()}
+  """
+
+#[ # TODO: Make these old partials into procs with inputs so they can be reused!
 const document* = """
 <!DOCTYPE html>
 <html lang="en-us">
@@ -141,7 +159,7 @@ const main* = """
 {{&.}}
 {{/blocks}}
 </main>
-"""
+""" ]#
 
 # https://css-tricks.com/emojis-as-favicons/ changed font-size to 80 to fit whale
 const faviconWhale* = """<link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2280%22>🐳</text></svg>">"""
@@ -189,7 +207,7 @@ figcaption {
   
 </style>"""
 
-const header* = """
+#[ const header* = """
 <header>
 <div class="nb-box">
   <span>{{> header_left }}</span>
@@ -231,7 +249,7 @@ function toggleSourceDisplay() {
 </script>"""
 
 proc optOut*(content, keyword: string): string =
-  "{{^" & keyword & "}}" & content & "{{/" & keyword & "}}"
+  "{{^" & keyword & "}}" & content & "{{/" & keyword & "}}" ]#
 
 proc useDefault*(doc: var NbDoc) =
   doc.context["path_to_root"] = %(doc.srcDirRel).string
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index b6f598f..d3e641f 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -1,6 +1,6 @@
 import mustache, std / tables, nimib / paths, std / parseopt
 export mustache, tables, paths
-import std / [os, json]
+import std / [os, json, strutils]
 
 type
   NbBlock* = ref object of RootObj
@@ -65,4 +65,10 @@ func render*(nb: Nb, blk: NbBlock): string =
   if blk.kind in nb.backend.funcs:
     nb.backend.funcs[blk.kind](blk, nb)
   else:
-    ""
\ No newline at end of file
+    ""
+
+func nbContainerToHtml*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbContainer
+  for b in blk.blocks:
+    result.add nb.render(b).strip & '\n'
+  result.strip
\ No newline at end of file

From 0bd3cb3c263ebdf2dfc2b05e637a5ac1a2a511cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 14:09:17 +0100
Subject: [PATCH 32/73] inheritance now works in newNbBlock macro

---
 src/nimib.nim             | 21 +++++++++---
 src/nimib/nimibSugars.nim | 68 ++++++++++++++++++++++++++++++++++++---
 src/nimib/types.nim       |  2 +-
 3 files changed, 81 insertions(+), 10 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 55ed5ef..4a13d41 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -2,8 +2,8 @@ import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
 import std / jsonutils except toJson
 export jsonutils
 import markdown
-import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils
+import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources] 
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -122,12 +122,24 @@ proc text*(nb: var Nb, text: string) =
 template nbText*(ttext: string) =
   nb.text(ttext)
 
+#[ template nbTextWithCode*(body: untyped) =
+  newNbCodeBlock("nbText", body):
+    nb.blk.output = body ]#
 
+newNbBlock(NbTextWithCode of NbText):
+  code: string
+  toHtml:
+    nbTextToHtml(blk, nb)
 
+template textWithCode*(nb: Nb, body: untyped) =
+  let ttext = body
+  let tcode = getCodeAsInSource(nb.doc.source, "textWithCode", body)
+  let blk = newNbTextWithCode(text=ttext, code=tcode)
+  nb.add blk
 
 template nbTextWithCode*(body: untyped) =
-  newNbCodeBlock("nbText", body):
-    nb.blk.output = body
+  nb.textWithCode:
+    body
 
 template nbImage*(url: string, caption = "", alt = "") =
   newNbSlimBlock("nbImage"):
@@ -283,7 +295,6 @@ template nbSave* =
   #   - in case you need to manage additional exceptions for a specific document add a new set of partials before calling nbSave
   nb.nbCollectAllNbJs()
 
-  echo "nb.doc.blocks: ", nb.doc.blocks
   #nb.context.searchDirs(nb.templateDirs)
   #nb.context.searchTable(nb.partials)
 
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index 5236660..983b87b 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -4,6 +4,56 @@ proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
   n.expectKind nnkCall
   (n[0].strVal, n[1][0])
 
+func getTypeFields*(typeSym: NimNode): seq[NimNode] =
+  ## return seq[nnkIdentDefs]
+  typeSym.expectKind nnkSym
+  # add all own fields
+  # look through typeSym.getImpl and look for OfInherit and recurse!
+  let typeDef = typeSym.getImpl
+  debugecho "typeDef of ", typeSym.repr, ":", typedef.repr
+  let ofInherit = typeDef[2][0][1]
+  if ofInherit.kind == nnkOfInherit:
+    let parentTypeSym = ofInherit[0]
+    if parentTypeSym.strVal != "RootObj":
+      result.add parentTypeSym.getTypeFields
+  let recList = typeDef[2][0][2]
+  result.add recList.children.toSeq
+
+func removePostfix*(identDef: NimNode): NimNode =
+  result = identDef.copyNimTree()
+  if result[0].kind == nnkPostfix:
+    result[0] = result[0][1]
+
+#[ var procParams = @[capitalizedTypeName.ident] & fieldsList
+var objectConstructor = nnkObjConstr.newTree(
+  capitalizedTypeName.ident
+)
+objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
+for (fName, _) in fields:
+  objectConstructor.add newColonExpr(fName.ident, fName.ident)
+var procBody = newStmtList(objectConstructor)
+
+var procName = postfix(ident("new" & capitalizedTypeName), "*")
+let initializer = newProc(procName, procParams, procBody) 
+
+echo "init:\n", initializer.repr
+]#
+macro generateBlockInitializer*(typeName: typed): untyped =
+  let fieldsList = typeName.getTypeFields().mapIt(it.removePostfix).filterIt(it[0].strVal != "kind")
+  let procParams = @[typeName] & fieldsList
+  var objectConstructor = nnkObjConstr.newTree(
+    typeName
+  )
+  objectConstructor.add newColonExpr(ident"kind", typeName.strVal.newLit)
+  for identDef in fieldsList:
+    let fieldName = identDef[0] 
+    objectConstructor.add newColonExpr(fieldName, fieldName)
+  let procBody = newStmtList(objectConstructor)
+  let procName = postfix(ident("new" & typeName.strVal), "*")
+  let initializer = newProc(procName, procParams, procBody)
+  echo "init:\n", initializer.repr
+  return initializer
+
 macro newNbBlock*(typeName: untyped, body: untyped): untyped =
   # typeName is either `ident` or
   # Infix
@@ -51,9 +101,16 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
     else:
       fields.add (name, body)
 
-  var fieldsList = nnkRecList.newTree()
+  var fieldsList: seq[NimNode]
+  var exportedFieldsList = nnkRecList.newTree()
   for (fName, fType) in fields:
     fieldsList.add newIdentDefs(fName.ident, fType)
+    exportedFieldsList.add newIdentDefs(postfix(fName.ident, "*"), fType)
+
+  # TODO: add parent list of fields to fieldsList as well!
+  # This probaly has to be done in a typed macro?
+  # In that case, let the typed macro construct the initializer!
+
   let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
     postfix(capitalizedTypeName.ident, "*"),
     newEmptyNode(), # generic
@@ -63,7 +120,7 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
         nnkOfInherit.newTree(
           parentType
         ),
-        fieldsList
+        exportedFieldsList
       )
     )
   ))
@@ -74,7 +131,10 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
   # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
   # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
 
-  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
+  let initializer = genAst(typeName = capitalizedTypeName.ident):
+    generateBlockInitializer(typeName)
+
+  #[ var procParams = @[capitalizedTypeName.ident] & fieldsList
   var objectConstructor = nnkObjConstr.newTree(
     capitalizedTypeName.ident
   )
@@ -86,7 +146,7 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
   var procName = postfix(ident("new" & capitalizedTypeName), "*")
   let initializer = newProc(procName, procParams, procBody)
 
-  echo "init:\n", initializer.repr
+  echo "init:\n", initializer.repr ]#
 
   # Next: generate nbImageToHtml from toHtmlBody
   let renderProcName = (lowercasedTypeName & "ToHtml").ident
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index d3e641f..60209e4 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -40,7 +40,7 @@ type
     containers*: seq[NbContainer] # current container
     backend*: NbRender # current backend
 
-proc `$`*(blk: NbBlock): string  = $blk[]
+#proc `$`*(blk: NbBlock): string  = $blk[]
 
 proc thisDir*(doc: NbDoc): AbsoluteDir = doc.thisFile.splitFile.dir
 proc srcDir*(doc: NbDoc): AbsoluteDir =

From f6800ed5f3aab4380d2b434546135493dcfb4e68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 15:27:17 +0100
Subject: [PATCH 33/73] make codeAsInSource not require the command as input

---
 src/nimib.nim         | 31 +++++++++++++++++++----
 src/nimib/sources.nim | 24 ++++++++++--------
 tests/tsources.nim    | 58 +++++++++++++++++++++----------------------
 3 files changed, 68 insertions(+), 45 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 4a13d41..fe45502 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -2,8 +2,8 @@ import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
 import std / jsonutils except toJson
 export jsonutils
 import markdown
-import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources
+import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight] 
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -81,10 +81,31 @@ template newNbSlimBlock*(cmd: string, blockImpl: untyped) =
   newNbBlock(cmd, false, nb, nb.blk, "", blockImpl)
 
 # block templates
-template nbCode*(body: untyped) =
+#[ template nbCode*(body: untyped) =
   newNbCodeBlock("nbCode", body):
     captureStdout(nb.blk.output):
-      body
+      body ]#
+
+newNbBlock(NbCode):
+  code: string
+  output: string
+  toHtml:
+    withNewlines:
+      # TODO: highlight code statically
+      &"<pre><code class=\"nohighlight hljs nim\">{blk.code.highlightNim}</code></pre>"
+      if blk.output.len > 0:
+        &"<pre class=\"nb-output\">{blk.output}</pre>"
+
+template code*(nb: Nb, body: untyped) =
+  let blk = newNbCode(code="", output="")
+  blk.code = getCode(body)
+  captureStdout(blk.output):
+    body
+  nb.add blk
+
+template nbCode*(body: untyped) =
+  nb.code:
+    body
 
 template nbCodeSkip*(body: untyped) =
   newNbCodeBlock("nbCodeSkip", body):
@@ -133,7 +154,7 @@ newNbBlock(NbTextWithCode of NbText):
 
 template textWithCode*(nb: Nb, body: untyped) =
   let ttext = body
-  let tcode = getCodeAsInSource(nb.doc.source, "textWithCode", body)
+  let tcode = getCode(body)
   let blk = newNbTextWithCode(text=ttext, code=tcode)
   nb.add blk
 
diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 30fe972..90f180c 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -88,7 +88,7 @@ proc findStartLine*(source: seq[string], startPos: Pos): int =
     return startPos.line - 1
 
 
-proc findEndLine*(source: seq[string], command: string, startLine, endPos: int): int =
+proc findEndLine*(source: seq[string], startsOnCommandLine: bool, startLine, endPos: int): int =
   result = endPos
   # Handle if line is an unclosed triple-quote string
   if source[endPos].count("\"\"\"") mod 2 == 1:
@@ -96,10 +96,10 @@ proc findEndLine*(source: seq[string], command: string, startLine, endPos: int):
     while result < source.high and source[result].count("\"\"\"") mod 2 == 0:
       inc result
   # Handle if there are ending comments
-  let startsOnCommandLine = source[startLine].isCommandLine(command)
+  #let startsOnCommandLine = source[startLine].isCommandLine(command)
   if result > startLine or not startsOnCommandLine:
     let baseIndent =
-      if source[startLine].isCommandLine(command):
+      if startsOnCommandLine:
         skipWhile(source[startLine], {' '}) + 1 # we want to add indent here.
         # this is problematic because we don't know the indentation of the code block because
         # we don't know the indentation size used. So we just add 1 and check that it is larger or equal.
@@ -109,19 +109,18 @@ proc findEndLine*(source: seq[string], command: string, startLine, endPos: int):
     while result < source.high and (source[result+1].startsWith(baseIndentStr) or source[result+1].isEmptyOrWhitespace):
       inc result
 
-proc getCodeBlock*(source, command: string, startPos, endPos: Pos): string =
+proc getCodeBlock*(source: string, startPos, endPos: Pos): string =
   ## Extracts the code in source from startPos to endPos with additional processing to get the entire code block.
   let rawLines = source.splitLines()
   let rawStartLine = startPos.line - 1
   let rawStartCol = startPos.column - 1
   var startLine = findStartLine(rawLines, startPos)
-  var endLine = findEndLine(rawLines, command, startLine, endPos.line - 1)
-
-  var lines = rawLines[startLine .. endLine]
-
   let startsOnCommandLine = block:
-    let preline = lines[0][0 ..< rawStartCol]
+    let preline = rawLines[startLine][0 ..< rawStartCol]
     startLine == rawStartLine and (not preline.isEmptyOrWhitespace) and (not (preline.nimIdentNormalize.strip() in ["for", "type"]))
+  var endLine = findEndLine(rawLines, startsOnCommandLine, startLine, endPos.line - 1)
+
+  var lines = rawLines[startLine .. endLine]
     
   if startsOnCommandLine:
     lines[0] = lines[0][rawStartCol .. ^1].strip()
@@ -145,7 +144,7 @@ proc getCodeBlock*(source, command: string, startPos, endPos: Pos): string =
         preserveIndent = not preserveIndent
     result = lines.join("\n")
 
-macro getCodeAsInSource*(source: string, command: static string, body: untyped): string =
+macro getCodeAsInSource*(source: string, body: untyped): string =
   ## Returns string for the code in body from source. 
   # substitute for `toStr` in blocks.nim
   let startPos = startPos(body)
@@ -165,4 +164,7 @@ macro getCodeAsInSource*(source: string, command: static string, body: untyped):
     If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 
     If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example."""
 
-    getCodeBlock(nb.doc.sourceFiles[`filename`], `command`, `startPosLit`, `endPosLit`)
\ No newline at end of file
+    getCodeBlock(nb.doc.sourceFiles[`filename`], `startPosLit`, `endPosLit`)
+
+template getCode*(body: untyped): string =
+  getCodeAsInSource(nb.doc.source, body)
\ No newline at end of file
diff --git a/tests/tsources.nim b/tests/tsources.nim
index d2af6ce..4689a7c 100644
--- a/tests/tsources.nim
+++ b/tests/tsources.nim
@@ -1,12 +1,12 @@
-import nimib, strformat
+import nimib, strformat, json
 import unittest
 
 suite "test sources":
-  template check =
+  template checkCode(t: typedesc = NbCode) =
     #echo &"---\n{nbBlock.code}\n"
     # the replace stuff needed on windows where the lines read from file will have windows native new lines
     test $currentTest:
-      actual = nbBlock.code
+      actual = nb.blk.t.code
       check actual.nbNormalize == expected.nbNormalize
       if actual.nbNormalize != expected.nbNormalize:
         echo &"===\n---actual:\n{actual.repr}\n---expected\n{expected.repr}\n---\n==="
@@ -25,7 +25,7 @@ suite "test sources":
 let
   x = 1
 """
-  check
+  checkCode()
 
   nbCode:
     # a comment
@@ -36,25 +36,25 @@ let
 let  # and a comment with nbCode
   y = 1
 """
-  check
+  checkCode()
 
   nbCode echo y
   expected = "echo y"
-  check
+  checkCode()
   nbCode: echo y
   expected = "echo y"
-  check
+  checkCode()
   nbCode(echo y)
   expected = "echo y"
-  check
+  checkCode()
   nbCode ((echo ("( This is ( weird string)")))
   expected = "echo (\"( This is ( weird string)\")"
-  check
+  checkCode()
 
   nbTextWithCode: """problem
 solution"""
   expected = "\"\"\"problem\nsolution\"\"\""
-  check
+  checkCode(NbTextWithCode)
 
   template discardBlock(body: untyped) = discard
 
@@ -65,7 +65,7 @@ solution"""
 discardBlock:
   echo y
 """
-  check
+  checkCode()
 
   nbCode:
     let garbage = 1
@@ -73,40 +73,40 @@ discardBlock:
   middle
 end"""
   expected = "let garbage = 1\nlet bigString = \"\"\"start\n  middle\nend\"\"\""
-  check
+  checkCode()
 
   nbCode:
     block:
       echo y
   expected = "block:\n  echo y"
-  check
+  checkCode()
 
   when not defined(nimibCodeFromAst):
     nbCode:
       echo y
       # This should be included!
     expected = "echo y\n# This should be included!"
-    check
+    checkCode()
 
     nbCode:
       echo y
 
       # Include this as well!
     expected = "echo y\n\n# Include this as well!"
-    check
+    checkCode()
 
     nbCode:
       echo y
     # Don't include this!
     expected = "echo y"
-    check
+    checkCode()
 
     nbCode:
 
       echo y
     # The newline at the beginning of the block!
     expected = "echo y"
-    check
+    checkCode()
 
     nbCode:
       block:
@@ -114,7 +114,7 @@ end"""
           b = 1
 
     expected = "block:\n  let\n    b = 1"
-    check
+    checkCode()
 
     template notNbCode(body: untyped) =
       nbCode:
@@ -124,7 +124,7 @@ end"""
       echo y
 
     expected = "echo y"
-    check
+    checkCode()
 
     template `&`(a,b: int) = discard
 
@@ -133,34 +133,34 @@ end"""
         2
 
     expected = "1 &\n  2"
-    check
+    checkCode()
 
     nbCode:
-      nb.context["no_source"] = true
+      nb.doc.context["no_source"] = %true
 
-    expected = "nb.context[\"no_source\"] = true"
-    check
+    expected = "nb.doc.context[\"no_source\"] = %true"
+    checkCode()
 
     nbCode: discard
     expected = "discard"
-    check
+    checkCode()
 
     nbCode:
       for n in 0 .. 1:
         discard
     expected = "for n in 0 .. 1:\n  discard"
-    check
+    checkCode()
 
     template nbCodeInTemplate =
       nbCode:
-        nb.renderPlans["nbText"] = @["mdOutputToHtml"]
+        nb.doc.context["nbText"] = %["mdOutputToHtml"]
 
     nbCodeInTemplate()
-    expected = """nb.renderPlans["nbText"] = @["mdOutputToHtml"]"""
-    check
+    expected = """nb.doc.context["nbText"] = %["mdOutputToHtml"]"""
+    checkCode()
 
     nbCode:
       type A = object
     expected = "type A = object"
-    check
+    checkCode()
   
\ No newline at end of file

From cab5c1be0463ddfc866cd958e34b91a72d15d199 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 16:55:52 +0100
Subject: [PATCH 34/73] implement nbCode-family of blocks (nimibCode is no
 longer needed!)

---
 src/nimib.nim             | 45 ++++++++++++++++++++++++++++++---------
 src/nimib/blocks.nim      |  2 +-
 src/nimib/nimibSugars.nim | 21 ++++++++++++++++--
 3 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index fe45502..38a1b93 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -1,9 +1,9 @@
 import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
 import std / jsonutils except toJson
-export jsonutils
+export jsonutils except toJson
 import markdown
 import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -86,35 +86,56 @@ template newNbSlimBlock*(cmd: string, blockImpl: untyped) =
     captureStdout(nb.blk.output):
       body ]#
 
-newNbBlock(NbCode):
+newNbBlock(NbCode of NbContainer):
   code: string
   output: string
   toHtml:
     withNewlines:
       # TODO: highlight code statically
-      &"<pre><code class=\"nohighlight hljs nim\">{blk.code.highlightNim}</code></pre>"
+      if blk.code.len > 0:
+        &"<pre><code class=\"nohighlight hljs nim\">{blk.code.highlightNim}</code></pre>"
+      nbContainerToHtml(blk, nb)
       if blk.output.len > 0:
         &"<pre class=\"nb-output\">{blk.output}</pre>"
 
 template code*(nb: Nb, body: untyped) =
-  let blk = newNbCode(code="", output="")
+  let blk = newNbCode()
   blk.code = getCode(body)
-  captureStdout(blk.output):
-    body
+  nb.withContainer(blk):
+    captureStdout(blk.output):
+      body
   nb.add blk
 
 template nbCode*(body: untyped) =
   nb.code:
     body
 
+template codeSkip*(nb: Nb, body: untyped) =
+  let blk = newNbCode()
+  blk.code = getCode(body)
+  nb.add blk
+
 template nbCodeSkip*(body: untyped) =
+  nb.codeSkip(body)
+
+#[ template nbCodeSkip*(body: untyped) =
   newNbCodeBlock("nbCodeSkip", body):
-    discard
+    discard ]#
+
+template capture*(nb: Nb, body: untyped) =
+  let blk = newNbCode()
+  nb.withContainer(blk):
+    captureStdout(blk.output):
+      body
+  nb.add blk
 
 template nbCapture*(body: untyped) =
+  nb.capture(body)
+
+#[ template nbCapture*(body: untyped) =
   newNbCodeBlock("nbCapture", body):
     captureStdout(nb.blk.output):
-      body
+      body ]#
 
 template nbCodeInBlock*(body: untyped): untyped =
   block:
@@ -122,9 +143,13 @@ template nbCodeInBlock*(body: untyped): untyped =
       body
 
 template nimibCode*(body: untyped) =
+  nbCode:
+    body
+
+#[ template nimibCode*(body: untyped) =
   newNbCodeBlock("nimibCode", body):
     discard
-  body
+  body ]#
 
 #[ template nbText*(text: string) =
   newNbSlimBlock("nbText"):
diff --git a/src/nimib/blocks.nim b/src/nimib/blocks.nim
index 3b92254..04926c6 100644
--- a/src/nimib/blocks.nim
+++ b/src/nimib/blocks.nim
@@ -24,7 +24,7 @@ proc add*(nb: var Nb, blk: NbBlock) =
     nb.containers[^1].blocks.add blk
 
 template withContainer*(nb: var Nb, container: NbContainer, body: untyped) =
-  nb.add container
+  # nb.add container # should this be here?
   nb.containers.add container
   body
   discard nb.containers.pop
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index 983b87b..127d21e 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -4,6 +4,15 @@ proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
   n.expectKind nnkCall
   (n[0].strVal, n[1][0])
 
+#[ this is what fields with default values look like
+Call
+    Ident "a"
+    StmtList
+      Asgn
+        Ident "string"
+        StrLit ""
+]#
+
 func getTypeFields*(typeSym: NimNode): seq[NimNode] =
   ## return seq[nnkIdentDefs]
   typeSym.expectKind nnkSym
@@ -39,7 +48,12 @@ let initializer = newProc(procName, procParams, procBody)
 echo "init:\n", initializer.repr
 ]#
 macro generateBlockInitializer*(typeName: typed): untyped =
-  let fieldsList = typeName.getTypeFields().mapIt(it.removePostfix).filterIt(it[0].strVal != "kind")
+  var fieldsList = typeName.getTypeFields().mapIt(it.removePostfix).filterIt(it[0].strVal != "kind")
+  for identDef in fieldsList:
+    identDef[2] = genAst(fieldType = identDef[1]):
+      default(typedesc[fieldType])
+  echo fieldsList.mapIt(it.repr)
+
   let procParams = @[typeName] & fieldsList
   var objectConstructor = nnkObjConstr.newTree(
     typeName
@@ -177,7 +191,10 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
 
 macro withNewlines*(body: untyped) : string =
   body.expectKind nnkStmtList
-  result = infix(body[0], "&", "\n".newLit)
+  result = body[0]
+  if result.kind == nnkIfStmt and result.findChild(it.kind == nnkElse).isNil:
+    result.add nnkElse.newTree("".newLit)
+  result = infix(result, "&", "\n".newLit)
   if body.len > 1:
     for line in body[1..^1]:
       # TODO: handle for loops

From 280a6e162e7fabf2bedc913cd9f4a0e62dc361d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 20:52:41 +0100
Subject: [PATCH 35/73] implement more blocks and use funcs where possible

---
 src/nimib.nim             | 117 +++++++++++++++++++++++++++++++++++---
 src/nimib/nimibSugars.nim |   8 +--
 2 files changed, 114 insertions(+), 11 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 38a1b93..bffeda8 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -137,11 +137,15 @@ template nbCapture*(body: untyped) =
     captureStdout(nb.blk.output):
       body ]#
 
-template nbCodeInBlock*(body: untyped): untyped =
+template codeInBlock*(nb: Nb, body: untyped) =
   block:
-    nbCode:
+    nb.code:
       body
 
+template nbCodeInBlock*(body: untyped): untyped =
+  nb.codeInBlock:
+    body
+
 template nimibCode*(body: untyped) =
   nbCode:
     body
@@ -161,7 +165,7 @@ newNbBlock(NbText):
     {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
       markdown(blk.text, config=initGfmConfig())
 
-proc text*(nb: var Nb, text: string) =
+func text*(nb: var Nb, text: string) =
   let blk = newNbText(text=text)
   nb.add blk
 
@@ -187,7 +191,33 @@ template nbTextWithCode*(body: untyped) =
   nb.textWithCode:
     body
 
+newNbBlock(NbImage):
+  url: string
+  caption: string
+  alt: string
+  toHtml:
+    &"""
+<figure>
+  <img src="{blk.url}" alt="{blk.alt}">
+  <figcaption>{blk.caption}</figcaption>
+</figure>
+"""
+
+func image*(nb: var Nb, turl: string, tcaption = "", talt = "") =
+  let blk = newNbImage()
+  blk.url = 
+    if isAbsolute(turl) or turl.startsWith("http"):
+      turl
+    else:
+      nb.doc.context{"path_to_root"}.getStr / turl
+  blk.alt = if talt.len == 0: tcaption else: talt
+  blk.caption = tcaption
+  nb.add blk
+
 template nbImage*(url: string, caption = "", alt = "") =
+  nb.image(url, caption, alt)
+
+#[ template nbImage*(url: string, caption = "", alt = "") =
   newNbSlimBlock("nbImage"):
     nb.blk.context["url"] =
       if isAbsolute(url) or url[0..3] == "http":
@@ -201,9 +231,47 @@ template nbImage*(url: string, caption = "", alt = "") =
       else:
         alt
         
-    nb.blk.context["caption"] = caption
+    nb.blk.context["caption"] = caption ]#
+
+newNbBlock(NbFile):
+  filename: string
+  ext: string
+  content: string
+  toHtml:
+    &"""
+<pre>{blk.filename}</pre>
+<pre><code class="{blk.ext} hljs">{blk.content}</code></pre>
+"""
+
+proc file*(nb: var Nb, tname: string, tcontent: string) =
+  ## Generic string file
+  tname.writeFile tcontent
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=tcontent)
+  nb.add blk
+
+template file*(nb: Nb, tname: string, body: untyped) =
+  ## Read code and write it to file
+  let content = getCode(body)
+  tname.writeFile content
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
+  nb.add blk
+
+proc file*(nb: var Nb, tname: string) =
+  ## Read content from a file instead of writing to it
+  let content = readFile(tname)
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
+  nb.add blk
 
 template nbFile*(name: string, content: string) =
+  nb.file(name, content)
+
+template nbFile*(name: string, body: untyped) =
+  nb.file(name, body)
+
+template nbFile*(name: string) =
+  nb.file(name)
+
+#[ template nbFile*(name: string, content: string) =
   ## Generic string file
   newNbSlimBlock("nbFile"):
     name.writeFile content
@@ -223,20 +291,55 @@ template nbFile*(name: string) =
   newNbSlimBlock("nbFile"):
     nb.blk.context["filename"] = name
     nb.blk.context["ext"] = name.getExt
-    nb.blk.context["content"] = readFile(name)
+    nb.blk.context["content"] = readFile(name) ]#
 
 when moduleAvailable(nimpy):
+  newNbBlock(NbPython of NbCode):
+    toHtml:
+      withNewlines:
+        if blk.code.len > 0:
+          &"<pre><code class=\"hljs python\">{blk.code}</code></pre>"
+        if blk.output.len > 0:
+          &"<pre class=\"nb-output\">{blk.output}</pre>"
+
   template nbInitPython*() =
     import nimpy
     let nbPythonBuiltins = pyBuiltinsModule()
 
+    proc python(nb: var Nb, pythonStr: string) =
+      let blk = newNbPython(code = pythonStr)
+      captureStdout(blk.output):
+          discard nbPythonBuiltins.exec(pythonStr)
+      nb.add blk
+    
     template nbPython(pythonStr: string) =
+      nb.python(pythonStr)
+
+    #[ template nbPython(pythonStr: string) =
       newNbSlimBlock("nbPython"):
         nb.blk.code = pythonStr
         captureStdout(nb.blk.output):
-          discard nbPythonBuiltins.exec(pythonStr)
+          discard nbPythonBuiltins.exec(pythonStr) ]#
+
+newNbBlock(NbRawHtml):
+  html: string
+  toHtml:
+    blk.html
+
+func rawHtml*(nb: var Nb, content: string) =
+  let blk = newNbRawHtml(html = content)
+  nb.add blk
+
+template nbRawHtml*(content: string) =
+  nb.rawHtml(content)
+
+func show*[T](nb: var Nb, obj: T) =
+  nb.rawHtml(obj.toHtml())
 
 template nbShow*(obj: untyped) =
+  nb.show(obj)
+
+#[ template nbShow*(obj: untyped) =
   nbRawHtml(obj.toHtml())
 
 template nbRawOutput*(content: string) {.deprecated: "Use nbRawHtml instead".} = 
@@ -244,7 +347,7 @@ template nbRawOutput*(content: string) {.deprecated: "Use nbRawHtml instead".} =
 
 template nbRawHtml*(content: string) =
   newNbSlimBlock("nbRawHtml"):
-    nb.blk.output = content
+    nb.blk.output = content ]#
 
 template nbJsFromStringInit*(body: string): NbBlock =
   var result = NbBlock(command: "nbJsFromCode", code: body, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index 127d21e..fc65c01 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -19,7 +19,7 @@ func getTypeFields*(typeSym: NimNode): seq[NimNode] =
   # add all own fields
   # look through typeSym.getImpl and look for OfInherit and recurse!
   let typeDef = typeSym.getImpl
-  debugecho "typeDef of ", typeSym.repr, ":", typedef.repr
+  #debugecho "typeDef of ", typeSym.repr, ":", typedef.repr
   let ofInherit = typeDef[2][0][1]
   if ofInherit.kind == nnkOfInherit:
     let parentTypeSym = ofInherit[0]
@@ -52,7 +52,7 @@ macro generateBlockInitializer*(typeName: typed): untyped =
   for identDef in fieldsList:
     identDef[2] = genAst(fieldType = identDef[1]):
       default(typedesc[fieldType])
-  echo fieldsList.mapIt(it.repr)
+  #echo fieldsList.mapIt(it.repr)
 
   let procParams = @[typeName] & fieldsList
   var objectConstructor = nnkObjConstr.newTree(
@@ -103,7 +103,7 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
   #         Ident "blk"
   #         Ident "url"
 
-  echo "Body:\n", body.treeRepr
+  #echo "Body:\n", body.treeRepr
 
   var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
   var toHtmlBody: NimNode
@@ -139,7 +139,7 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
     )
   ))
 
-  echo "Type:\n", typeDefinition.repr
+  #echo "Type:\n", typeDefinition.repr
 
   # Next: generate initializer with prefilled kind
   # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?

From 0686e3a314d76e93132c34937dfca71825267c93 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 21:35:48 +0100
Subject: [PATCH 36/73]  implement nbJs blocks

---
 src/nimib.nim             | 61 ++++++++++++++++++++++++++++++++++-----
 src/nimib/jsutils.nim     |  8 ++---
 src/nimib/nimibSugars.nim |  5 +++-
 3 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index bffeda8..941cafa 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -349,25 +349,70 @@ template nbRawHtml*(content: string) =
   newNbSlimBlock("nbRawHtml"):
     nb.blk.output = content ]#
 
-template nbJsFromStringInit*(body: string): NbBlock =
+func nbJsFromStringInit*(body: string): NbBlock =
+  newNbJsFromCode(code=body, transformedCode=body, putAtTop=false)
+
+#[ template nbJsFromStringInit*(body: string): NbBlock =
   var result = NbBlock(command: "nbJsFromCode", code: body, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
   result.context["transformedCode"] = body
   result.context["putAtTop"] = false
-  result
+  result ]#
+
+func addStringToJs*(script: NbJsFromCode or NbJsFromCodeOwnFile, body: string) =
+  script.code &= "\n" & body
+  script.transformedCode &= "\n" & body
 
-template addStringToJs*(script: NbBlock, body: string) =
+#[ template addStringToJs*(script: NbBlock, body: string) =
   script.code &= "\n" & body
-  script.context["transformedCode"] = script.context["transformedCode"].vString & "\n" & body
+  script.context["transformedCode"] = script.context["transformedCode"].vString & "\n" & body ]#
+
+#[ func addToDocAsJs*(nb: var Nb, script: NbBlock) =
+  nb.add script
 
 template addToDocAsJs*(script: NbBlock) =
   nb.blocks.add script
-  nb.blk = script
+  nb.blk = script ]#
 
-template nbJsFromString*(body: string) =
+func jsFromString*(nb: var Nb, body: string) =
   let script = nbJsFromStringInit(body)
-  script.addToDocAsJs
+  nb.add script
+
+template nbJsFromString*(body: string) =
+  nb.jsFromString(body)
+
+template jsFromCode*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
+  nb.add blk
 
 template nbJsFromCode*(args: varargs[untyped]) =
+  nb.jsFromCode(args)
+
+template jsFromCodeInBlock*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=true, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
+  nb.add blk
+
+template nbJsFromCodeInBlock*(args: varargs[untyped]) =
+  nb.jsFromCodeInBlock(args)
+
+template jsFromCodeGlobal*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=true)
+  nb.add blk
+
+template nbJsFromCodeGlobal*(args: varargs[untyped]) =
+  nb.jsFromCodeGlobal(args)
+
+template jsFromCodeOwnFile*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCodeOwnFile(code=originalCode, transformedCode=code)
+  nb.add blk
+
+template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
+  nb.jsFromCodeOwnFile(args)
+
+#[ template nbJsFromCode*(args: varargs[untyped]) =
   let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
   var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
   result.context["transformedCode"] = code
@@ -395,7 +440,7 @@ template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
   result.addToDocAsJs
 
 template nbCodeToJs*(args: varargs[untyped]) {.deprecated: "Use nbJsFromCode or nbJsFromString instead".} =
-  nbJsFromCode(args)
+  nbJsFromCode(args) ]#
 
 
 when moduleAvailable(karax/kbase):
diff --git a/src/nimib/jsutils.nim b/src/nimib/jsutils.nim
index aaff0fb..d83a984 100644
--- a/src/nimib/jsutils.nim
+++ b/src/nimib/jsutils.nim
@@ -2,7 +2,7 @@ import std / [macros, macrocache, tables, strutils, strformat, sequtils, sugar,
 import ./types, ./nimibSugars, ./globals, ./jsons, ./blocks
 
 
-newNbBlock(NbJsFromCode):
+newNbBlock(NbJsFromCode): # should inherit from nbCode, but it is defined in nimib.nim...
   code: string
   transformedCode: string
   putAtTop: bool
@@ -19,12 +19,10 @@ newNbBlock(NbJsFromCodeOwnFile):
   jsCode: string
   showCode: bool
   toHtml:
-    result =
+    withNewlines:
       if blk.showCode:
         "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
-      else:
-        ""
-    result &= &"<script>\n{blk.jsCode}\n</script>"
+      &"<script>\n{blk.jsCode}\n</script>"
 
 proc contains(tab: CacheTable, keyToCheck: string): bool =
   for key, val in tab:
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index fc65c01..547e5b8 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -2,7 +2,10 @@ import std / [macros, strutils, sequtils, genasts]
 
 proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
   n.expectKind nnkCall
-  (n[0].strVal, n[1][0])
+  if n[1].len > 1: # toHtml case
+    (n[0].strVal, n[1])
+  else: # field case
+    (n[0].strVal, n[1][0])
 
 #[ this is what fields with default values look like
 Call

From d0f3cb03fe91ec6de9c10c8e306a8d7156b20821 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 21 Feb 2025 23:28:21 +0100
Subject: [PATCH 37/73] implement the last few blocks

---
 src/nimib.nim | 43 +++++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 941cafa..9812a94 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -444,43 +444,54 @@ template nbCodeToJs*(args: varargs[untyped]) {.deprecated: "Use nbJsFromCode or
 
 
 when moduleAvailable(karax/kbase):
-  template nbKaraxCode*(args: varargs[untyped]) =
-    let rootId = "karax-" & $nb.newId()
-    nbRawHtml: "<div id=\"" & rootId & "\"></div>"
+  template karaxCode*(nb: var Nb, args: varargs[untyped]) =
+    let rootId = "karax-" & $nb.doc.newId()
+    nb.rawHtml: "<div id=\"" & rootId & "\"></div>"
     nbKaraxCodeBackend(rootId, args)
 
+  template nbKaraxCode*(args: varargs[untyped]) =
+    nb.karaxCode(args)
+
 when moduleAvailable(happyx):
-  template nbHappyxCode*(args: varargs[untyped]) =
-    let rootId = "happyx-" & $nb.newId()
+  template happyxCode*(nb: var Nb, args: varargs[untyped]) =
+    let rootId = "happyx-" & $nb.doc.newId()
     nbRawHtml: "<div id=\"" & rootId & "\"></div>"
     nbHappyxCodeBackend(rootId, args)
 
-template nbJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
+  template nbHappyxCode*(args: varargs[untyped]) =
+    nb.happyxCode(args)
+
+#[ template nbJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
   nb.blk.context["js_show_nim_source"] = true
   if message.len > 0:
     nb.blk.context["js_show_nim_source_message"] = message
 
 template nbCodeToJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
-  nbJsShowSource(message)
+  nbJsShowSource(message) ]#
 
-template nbCodeDisplay*(tmplCall: untyped, body: untyped) =
-  ## display codes used in a template (e.g. nbJsFromCode) after the template call
+template codeDisplay*(nb: var Nb, tmplCall: untyped, body: untyped) =
   tmplCall:
     body
-  newNbCodeBlock("nbCode", body):
-    discard
+  nb.codeSkip:
+    body
 
-template nbCodeAnd*(tmplCall: untyped, body: untyped) =
+template nbCodeDisplay*(tmplCall: untyped, body: untyped) =
+  ## display codes used in a template (e.g. nbJsFromCode) after the template call
+  nb.codeDisplay(tmplCall, body)
+
+template codeAnd*(nb: var Nb, tmplCall: untyped, body: untyped) =
   ## can be used to run code both in c and js backends (e.g. nbCodeAnd(nbJsFromCode))
-  nbCode: # this should work because template name starts with nbCode
+  nb.code: # this should work because template name starts with nbCode
     body
   tmplCall:
     body
 
+template nbCodeAnd*(tmplCall: untyped, body: untyped) =
+  nb.codeAnd(tmplCall, body)
+
 template nbClearOutput*() =
-  if not nb.blk.isNil:
-    nb.blk.output = ""
-    nb.blk.context["output"] = ""
+  if not nb.blk.isNil and nb.blk of NbCode:
+    nb.blk.NbCode.output = ""
 
 template nbSave* =
   # order if searchDirs/searchTable is relevant: directories have higher priority. rationale:

From 2c0d5ca280ea79a51189891433036df81f2c9cbe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 08:42:41 +0100
Subject: [PATCH 38/73] fix miss in merging

---
 src/nimib.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 3dd92ba..cd7d728 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -49,7 +49,7 @@ template nbInit*(theme = themes.useDefault, renderer: NbRender = nbToHtml, thisF
   if nb.doc.cfg.homeDir != "":
     if not dirExists(nb.doc.homeDir):
       log "creating nb.homeDir: " & $nb.doc.homeDir
-      createDir(nb.homeDir)
+      createDir(nb.doc.homeDir)
 
     log "setting current directory to nb.doc.homeDir: " & $nb.doc.homeDir
     setCurrentDir nb.doc.homeDir

From 5c47bf23c99fe91370966e59e3b1bdbe48938068 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 09:12:33 +0100
Subject: [PATCH 39/73] port nbVideo and nbAudio

---
 src/nimib.nim | 75 ++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 54 insertions(+), 21 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index cd7d728..490a2fc 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -261,28 +261,61 @@ proc file*(nb: var Nb, tname: string) =
   let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
   nb.add blk
 
+newNbBlock(NbVideo):
+  url: string
+  filetype: string
+  autoplay: bool
+  muted: bool
+  loop: bool
+  toHtml:
+    withNewLines:
+      "<video controls"
+      if blk.loop: "loop"
+      if blk.autoplay: "autoplay"
+      if blk.muted: "muted"
+      ">"
+      &"""<source src="{blk.url}" """
+      if blk.filetype.len > 0:
+        &"""type="{blk.filetype}" """
+      ">"
+      "Your browser does not support the video element.</video>"
+
+func video*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  let blk = newNbVideo(autoplay=autoplay, muted=muted, loop=loop)
+  blk.url = nb.doc.relToRoot(url)
+  blk.filetype = 
+    if filetype == "": "video/" & url.splitFile.ext[1..^1] # remove the leading dot
+    else: filetype
+  nb.add blk
+  
 # todo captions and subtitles support maybe?
-template nbVideo*(url: string, typ: string = "", autoplay = false, muted = false, loop: bool = false) =
-  newNbSlimBlock("nbVideo"):
-    nb.blk.context["url"] = nb.relToRoot(url)
-    nb.blk.context["type"] =
-      if typ == "": "video/" & url.splitFile.ext[1..^1] # remove the leading dot
-      else: typ
-
-    if autoplay: nb.blk.context["autoplay"] = "autoplay"
-    if muted: nb.blk.context["muted"] = "muted"
-    if loop: nb.blk.context["loop"] = "loop"
-
-template nbAudio*(url: string, typ: string = "", autoplay = false, muted = false, loop: bool = false) =
-  newNbSlimBlock("nbAudio"):
-    nb.blk.context["url"] = nb.relToRoot(url)
-    nb.blk.context["type"] = 
-      if typ == "": "audio/" & url.splitFile.ext[1..^1]
-      else: typ
-
-    if autoplay: nb.blk.context["autoplay"] = "autoplay"
-    if muted: nb.blk.context["muted"] = "muted"
-    if loop: nb.blk.context["loop"] = "loop"
+template nbVideo*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  nb.video(url, filetype, autoplay, muted, loop)
+
+newNbBlock(NbAudio of NbVideo):
+  toHtml: 
+    withNewLines:
+      "<audio controls"
+      if blk.loop: "loop"
+      if blk.autoplay: "autoplay"
+      if blk.muted: "muted"
+      ">"
+      &"""<source src="{blk.url}" """
+      if blk.filetype.len > 0:
+        &"""type="{blk.filetype}" """
+      ">"
+      "Your browser does not support the video element.</audio>"
+
+func audio*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  let blk = newNbAudio(autoplay=autoplay, muted=muted, loop=loop)
+  blk.url = nb.doc.relToRoot(url)
+  blk.filetype = 
+    if filetype == "": "audio/" & url.splitFile.ext[1..^1] # remove the leading dot
+    else: filetype
+  nb.add blk
+
+template nbAudio*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  nb.audio(url, filetype, autoplay, muted, loop)
 
 template nbFile*(name: string, content: string) =
   nb.file(name, content)

From 501818911d26efe165fbbb9d83184bec177c1b17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 10:08:22 +0100
Subject: [PATCH 40/73] start fixing docs

---
 docsrc/allblocks.nim      | 12 ++++++------
 docsrc/cheatsheet.nim     |  3 ++-
 docsrc/far/from/home.nim  |  4 ++--
 docsrc/index.nim          | 12 ++++++------
 docsrc/nolan.nim          | 10 +++++-----
 docsrc/numerical.nim      | 20 ++++++++++----------
 docsrc/pythno.nim         |  5 +++--
 nimib.nimble              |  9 ++++-----
 src/nimib.nim             |  6 +++---
 src/nimib/nimibSugars.nim |  4 ++--
 src/nimib/renders.nim     |  4 +++-
 src/nimib/themes.nim      | 12 ++++++++++++
 src/nimib/types.nim       |  3 +++
 13 files changed, 61 insertions(+), 43 deletions(-)

diff --git a/docsrc/allblocks.nim b/docsrc/allblocks.nim
index 460cb8d..a82a3a4 100644
--- a/docsrc/allblocks.nim
+++ b/docsrc/allblocks.nim
@@ -4,17 +4,17 @@ import std/[strutils, strformat]
 
 nbInit
 
-var nbToc: NbBlock
+var nbToc: NbText
 
 template addToc =
-  newNbBlock("nbText", false, nb, nbToc, ""):
-    nbToc.output = "## Table of Contents:\n\n"
+  nbToc = newNbText(text="## Table of Contents:\n\n")
+  nb.add nbToc
 
-template nbCodeBlock(name:string) =
+template nbCodeBlock(name: string) =
   let anchorName = name.toLower.replace(" ", "-")
   nbText "<a name = \"" & anchorName & "\"></a>\n### " & name & "\n\n---"
   # see below, but any number works for a numbered list
-  nbToc.output.add "1. <a href=\"#" & anchorName & "\">" & name & "</a>\n"
+  nbToc.text.add "1. <a href=\"#" & anchorName & "\">" & name & "</a>\n"
 
 nbText: """
 > This nimib document provides a brief description and example for 
@@ -120,7 +120,7 @@ The `typ` parameter specifies the video's MIME type, and is optional!
 """
 
 nimibCode:
-  nbVideo(url="media/bad_apple!!.mp4", typ="video/mp4")
+  nbVideo(url="media/bad_apple!!.mp4", filetype="video/mp4")
 
 nbCodeBlock: "nbAudio"
 nbText: """
diff --git a/docsrc/cheatsheet.nim b/docsrc/cheatsheet.nim
index 3f10f99..cfa26fc 100644
--- a/docsrc/cheatsheet.nim
+++ b/docsrc/cheatsheet.nim
@@ -14,8 +14,9 @@ nbText: """
 > Quoted sections will be used to mention differences with the original source.
 """
 
+# is this block needed? for markdown, yes but hljs is already included!
 # customize source highlighting:
-nb.context["highlight"] = """
+nb.doc.context["highlight"] = %"""
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/styles/default.min.css">
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad();</script>"""
diff --git a/docsrc/far/from/home.nim b/docsrc/far/from/home.nim
index 71b219c..f3187b9 100644
--- a/docsrc/far/from/home.nim
+++ b/docsrc/far/from/home.nim
@@ -1,7 +1,7 @@
 import nimib, strutils
 nbInit
-nb.context["path_to_root"] = nb.context["path_to_root"].castStr.replace("/", r"\") # for CI since I run locally on Windows and CI runs on Linux: behaviour is the same
-nb.context["path_to_here"] = nb.context["path_to_here"].castStr.replace("/", r"\") # for CI since I run locally on Windows and CI runs on Linux: behaviour is the same
+nb.doc.context["path_to_root"] = %nb.doc.context{"path_to_root"}.getStr.replace("/", r"\") # for CI since I run locally on Windows and CI runs on Linux: behaviour is the same
+nb.doc.context["path_to_here"] = %nb.doc.context{"path_to_here"}.getStr.replace("/", r"\") # for CI since I run locally on Windows and CI runs on Linux: behaviour is the same
 nb.partials["document"] = """
 <html>
 <head></head>
diff --git a/docsrc/index.nim b/docsrc/index.nim
index b9a4b6d..cf2b37b 100644
--- a/docsrc/index.nim
+++ b/docsrc/index.nim
@@ -12,7 +12,7 @@ nb.title = "Nimib Docs"
 let
   repo = "https://github.com/pietroppeter/nimib"
   docs = if defined(mdOutput): "https://pietroppeter.github.io/nimib" else: "."
-  hello = read(nb.srcDir / "hello.nim".RelativeFile)
+  hello = read(nb.doc.srcDir / "hello.nim".RelativeFile)
 
 nbText: hlMdF"""
 # nimib :whale: - nim :crown: driven :sailboat: publishing :writingHand:
@@ -65,13 +65,13 @@ provides syntax highlighting of embedded languages in nimib documents (eg. markd
 
 First have a look at the following html document: [hello.html]({docs}/hello.html)
 
-This was produced with `nim r {nb.cfg.srcDir}/hello`, where [{nb.cfg.srcDir}/hello.nim]({repo}/blob/main/{nb.cfg.srcDir}/hello.nim) is:
+This was produced with `nim r {nb.doc.cfg.srcDir}/hello`, where [{nb.doc.cfg.srcDir}/hello.nim]({repo}/blob/main/{nb.doc.cfg.srcDir}/hello.nim) is:
 """.emojize
 
 
 when not defined(mdOutput):
   nbCode: discard
-  nb.blk.code = hello  # "\n" should not be needed here (fix required in rendering)
+  nb.blk.NbCode.code = hello  # "\n" should not be needed here (fix required in rendering)
 else:
   nbText &"""
 ```nim
@@ -124,7 +124,7 @@ The following are the main elements of a default nimib document:
 * (optional) latex rendering through [katex](https://katex.org/) (see below)
 * a header with navigation to a home page, a minimal title and an automatic detection of github repo (with link)
 * a footer with a "made with nimib" line and a `Show source` button that shows the full source to create the document.
-* (optional) possibility to create a markdown version of the same document (see this document for an example: [{nb.cfg.srcDir}/index.nim]({repo}/blob/main/{nb.cfg.srcDir}/index.nim))
+* (optional) possibility to create a markdown version of the same document (see this document for an example: [{nb.doc.cfg.srcDir}/index.nim]({repo}/blob/main/{nb.doc.cfg.srcDir}/index.nim))
 
 Customization over the default is mostly achieved through nim-mustache or changing
 `NbDoc` and `NbBlock` elements (see below api).
@@ -210,7 +210,7 @@ All the options available can be seen by running any nimib file with option `nbH
 
 nbCode:
   import osproc
-  withDir nb.srcDir:
+  withDir nb.doc.srcDir:
     echo execProcess("nim r --verbosity:0 --hints:off --warnings:off hello --nbHelp")
 
 let renderProcType = "type NbRenderProc = proc (doc: var NbDoc, blk: var NbBlock) {. nimcall .}"
@@ -338,7 +338,7 @@ and they tell me [imitation is the sincerest form of flattery](https://www.goodr
 """.emojize
 
 when defined(mdOutput):
-  nb.filename = "../README.md"
+  nb.doc.filename = "../README.md"
   nbSave
 else:
   nbSave
diff --git a/docsrc/nolan.nim b/docsrc/nolan.nim
index 4c74069..8b57456 100644
--- a/docsrc/nolan.nim
+++ b/docsrc/nolan.nim
@@ -11,7 +11,7 @@ nbText: """
 >
 > It reorders a **Limerick** according to Nolan's [Memento film structure](https://en.wikipedia.org/wiki/Memento_(film)#Film_structure).
 """
-let filename_variant = nb.filename.replace(".html", "_no_source.html")
+let filename_variant = nb.doc.filename.replace(".html", "_no_source.html")
 let iChange = nb.blocks.len
 nbText:fmt"""
 > Click on `Show Source` at the bottom to see the nim file that generates this document.
@@ -48,11 +48,11 @@ nbSave
 # save another document without source to test the opt-out of Show Source feature
 nbText: "---\n> This is how we can remove the `Show Source` functionality"
 nbCode:
-  nb.context["no_source"] = true
+  nb.doc.context["no_source"] = %true
 # we will generate this last block to change a previous block and then remove it
 nbText:fmt"""
-> To see the variant with Show Source [click here]({(nb.filename.AbsoluteFile).relPath})
+> To see the variant with Show Source [click here]({(nb.doc.filename.AbsoluteFile).relPath})
 """
-nb.blocks[iChange] = nbDoc.blocks.pop
-nb.filename = filename_variant
+nb.blocks[iChange] = nb.blocks.pop
+nb.doc.filename = filename_variant
 nbSave
\ No newline at end of file
diff --git a/docsrc/numerical.nim b/docsrc/numerical.nim
index 0c4b310..7814e77 100644
--- a/docsrc/numerical.nim
+++ b/docsrc/numerical.nim
@@ -3,14 +3,14 @@ import nimib, strformat, strutils
 nbInit
 nb.useLatex
 let
-  filename_default_style = nb.filename.replace(".html", "_default_style.html")
-  default_style = nb.context["stylesheet"]
+  filename_default_style = nb.doc.filename.replace(".html", "_default_style.html")
+  default_style = nb.doc.context["stylesheet"]
 
-nb.context["stylesheet"] = """<link rel="stylesheet" href="https://latex.now.sh/style.css">"""
+nb.doc.context["stylesheet"] = %"""<link rel="stylesheet" href="https://latex.now.sh/style.css">"""
 
 proc introText(defaultStyle = false): string =
   let otherStyle = if defaultStyle:
-    fmt"; _you are looking at default style, for custom style [click here]({(nb.filename.AbsoluteFile).relPath})_"
+    fmt"; _you are looking at default style, for custom style [click here]({(nb.doc.filename.AbsoluteFile).relPath})_"
   else:
     fmt"; _for default style [click here]({(filename_default_style.AbsoluteFile).relPath})_"
 
@@ -26,7 +26,7 @@ proc introText(defaultStyle = false): string =
 
 nbText: introText()
 # save to change later
-var blockIntroText = nb.blk
+var blockIntroText = nb.blk.NbText
 
 nbText: fmt"""# Using NumericalNim
 
@@ -128,17 +128,17 @@ $h=0.01$ | {pe y3hn[^1]} | {pe y3rk[^1]}
 
 and here is the code for this Markdown block:
 """ # right alignment of numbers does not seem to work. is this an issue of latex.css?
-let mdCode = nb.blk.code
+let mdCode = nb.blk.NbTextWithCode.code
 nbCode:
   discard
-nb.blk.code = mdCode
+nb.blk.NbCode.code = mdCode
 # add a show Markdown source. It would be nice when hovering a code block to show (on the side? how to do it on mobile?) the call code (nbText: or other)
 
 # first save with latex style
 nbSave
 
 # then save with default style
-blockIntroText.output = introText(default_style=true)
-nb.filename = filename_default_style
-nb.context["stylesheet"] = default_style 
+blockIntroText.text = introText(default_style=true)
+nb.doc.filename = filename_default_style
+nb.doc.context["stylesheet"] = default_style 
 nbSave
diff --git a/docsrc/pythno.nim b/docsrc/pythno.nim
index ac4fd6d..27e946d 100644
--- a/docsrc/pythno.nim
+++ b/docsrc/pythno.nim
@@ -25,8 +25,9 @@ nbCode:
   
   echo repeat("ThisIsNotPython", 6)
 
-nb.blk.context["output"] = camel2snake(nb.blk.output)
-nb.blk.code = nb.blk.code.multiReplace([
+let codeBlock = nb.blk.NbCode
+codeBlock.output = camel2snake(codeBlock.output)
+codeBlock.code = codeBlock.code.multiReplace([
   ("proc", "def"),
   ("string", "str"),
   (";", ","), # tricky one
diff --git a/nimib.nimble b/nimib.nimble
index 850b6a3..157eedc 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -29,9 +29,8 @@ task readme, "update readme":
 
 task docs, "Build documentation":
   for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
-    "pythno", "cheatsheet", "files", "index",
-    "interactivity", "counters", "caesar"]:
+    "pythno", "index"]: # , "cheatsheet", "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
-  when not defined(nimibDocsSkipPenguins):
-    exec "nim r --hints:off docsrc/penguins.nim"
-  exec "nimble readme"  
+  #when not defined(nimibDocsSkipPenguins):
+  #  exec "nim r --hints:off docsrc/penguins.nim"
+  #exec "nimble readme"  
diff --git a/src/nimib.nim b/src/nimib.nim
index 490a2fc..18d4efa 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -3,7 +3,7 @@ import std / jsonutils except toJson
 export jsonutils except toJson
 import markdown
 import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons, json
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -74,7 +74,7 @@ template nbInitMd*(thisFileRel = "") =
   nbInit(backend=renders.useMdBackend, theme=themes.noTheme, tfr)
 
   if nb.options.filename == "":
-    nb.filename = nb.filename.splitFile.name & ".md"
+    nb.doc.filename = nb.doc.filename.splitFile.name & ".md"
 
 # block generation templates
 template newNbCodeBlock*(cmd: string, body, blockImpl: untyped) =
@@ -564,7 +564,7 @@ template nbSave* =
 
 # how to change this to a better version using nb?
 template relPath*(path: AbsoluteFile | AbsoluteDir): string =
-  (path.relativeTo nb.homeDir).string
+  (path.relativeTo nb.doc.homeDir).string
 
 # aliases to minimize breaking changes after refactoring nbDoc -> nb. Should be deprecated at some point?
 #[ template nbDoc*: NbDoc = nb
diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index 547e5b8..2f1bb04 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -68,7 +68,7 @@ macro generateBlockInitializer*(typeName: typed): untyped =
   let procBody = newStmtList(objectConstructor)
   let procName = postfix(ident("new" & typeName.strVal), "*")
   let initializer = newProc(procName, procParams, procBody)
-  echo "init:\n", initializer.repr
+  #echo "init:\n", initializer.repr
   return initializer
 
 macro newNbBlock*(typeName: untyped, body: untyped): untyped =
@@ -188,7 +188,7 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
     hookAssignements
   )
 
-  echo result.repr
+  #echo result.repr
 
   #assert false
 
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index ba7a32c..d9dd2f7 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -84,7 +84,9 @@ Your browser does not support the audio element.
   doc.renderProcs["highlightCode"] = highlightCode
   doc.renderProcs["compileNimToJs"] = compileNimToJs ]#
 
-#[ proc useMdBackend*(doc: var NbDoc) =
+proc useMdBackend*(doc: var NbDoc) =
+  discard
+#[
   doc.partials["document"] = """
 {{#blocks}}
 
diff --git a/src/nimib/themes.nim b/src/nimib/themes.nim
index a1d6753..4d6d8c4 100644
--- a/src/nimib/themes.nim
+++ b/src/nimib/themes.nim
@@ -288,15 +288,27 @@ proc darkMode*(doc: var NbDoc) =
   doc.context["github_logo"] = %githubLogoDark
   doc.context["highlight"] = %androidStudio
 
+proc darkMode*(nb: var Nb) =
+  nb.doc.darkMode()
+
 proc useLatex*(doc: var NbDoc) =
   doc.context["latex"] = %latex
 
+proc useLatex*(nb: var Nb) =
+  nb.doc.useLatex()
+
 proc disableHighlightJs*(doc: var NbDoc) =
   doc.context["disableHighlightJs"] = %true
 
+proc disableHighlightJs*(nb: var Nb) =
+  nb.doc.disableHighlightJs()
+
 proc `title=`*(doc: var NbDoc, text: string) =
   # to deprecate?
   doc.context["title"] = %text
 
+proc `title=`*(nb: var Nb, text: string) =
+  `title=`(nb.doc, text)
+
 proc noTheme*(doc: var NbDoc) =
   discard
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index 60209e4..5fb8e96 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -60,6 +60,9 @@ proc newId*(doc: var NbDoc): int =
   result = doc.id
   inc doc.id
 
+proc blocks*(nb: var Nb): var seq[NbBlock] =
+  nb.doc.blocks
+
 func render*(nb: Nb, blk: NbBlock): string =
   debugecho "REndering block: ", blk[]
   if blk.kind in nb.backend.funcs:

From 1478f868996a85df897141ca0ed4644d722118ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 10:31:37 +0100
Subject: [PATCH 41/73] remove allblocks from build for now

---
 nimib.nimble | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nimib.nimble b/nimib.nimble
index 157eedc..af3e79f 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -28,8 +28,8 @@ task readme, "update readme":
   exec "nim -d:mdOutput r docsrc/index.nim"  
 
 task docs, "Build documentation":
-  for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
-    "pythno", "index"]: # , "cheatsheet", "files", "interactivity", "counters", "caesar"]:
+  for file in ["hello", "mostaccio", "numerical", "nolan",
+    "pythno", "index"]: # "allblocks", "cheatsheet", "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
   #when not defined(nimibDocsSkipPenguins):
   #  exec "nim r --hints:off docsrc/penguins.nim"

From 7385cc86f23888cb74ae120ed436a17fa999ee8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 10:55:47 +0100
Subject: [PATCH 42/73] update ci nim version

---
 .github/workflows/docs.yml               | 2 +-
 .github/workflows/netlify_build_docs.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index cac2e8d..311058b 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -9,7 +9,7 @@ jobs:
       - uses: actions/checkout@v2
       - name: install nim
         id: install_nim
-        uses: iffy/install-nim@v3
+        uses: iffy/install-nim@v5
       - name: install library dependencies
         run: nimble install -y
       - name: install doc dependencies
diff --git a/.github/workflows/netlify_build_docs.yml b/.github/workflows/netlify_build_docs.yml
index 63be024..5b7deaf 100644
--- a/.github/workflows/netlify_build_docs.yml
+++ b/.github/workflows/netlify_build_docs.yml
@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v2
       - name: install nim
         id: install_nim
-        uses: iffy/install-nim@v3
+        uses: iffy/install-nim@v5
       - name: install library dependencies
         run: nimble install -y
       - name: install doc dependencies

From eee9efe34998c4e01600f2b27a1f1abfe9389c24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 11:11:13 +0100
Subject: [PATCH 43/73] add install libpcre3

---
 .github/workflows/netlify_build_docs.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/netlify_build_docs.yml b/.github/workflows/netlify_build_docs.yml
index 5b7deaf..1fd789a 100644
--- a/.github/workflows/netlify_build_docs.yml
+++ b/.github/workflows/netlify_build_docs.yml
@@ -8,6 +8,8 @@ jobs:
   tests:
     runs-on: ubuntu-latest
     steps:
+      - name: apt install
+        run: sudo apt install -y libpcre3
       - uses: actions/checkout@v2
       - name: install nim
         id: install_nim

From 5c6944646e9d9957a4fc084de97de923e628d4cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 11:26:30 +0100
Subject: [PATCH 44/73] test adding allblocks again

---
 nimib.nimble          | 4 ++--
 src/nimib/sources.nim | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/nimib.nimble b/nimib.nimble
index af3e79f..1a2f2bb 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -28,8 +28,8 @@ task readme, "update readme":
   exec "nim -d:mdOutput r docsrc/index.nim"  
 
 task docs, "Build documentation":
-  for file in ["hello", "mostaccio", "numerical", "nolan",
-    "pythno", "index"]: # "allblocks", "cheatsheet", "files", "interactivity", "counters", "caesar"]:
+  for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
+    "pythno", "index"]: #, "cheatsheet", "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
   #when not defined(nimibDocsSkipPenguins):
   #  exec "nim r --hints:off docsrc/penguins.nim"
diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 90f180c..81a3ef6 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -159,6 +159,7 @@ macro getCodeAsInSource*(source: string, body: untyped): string =
     if `filename` notin nb.doc.sourceFiles:
       nb.doc.sourceFiles[`filename`] = readFile(`filename`)
 
+    echo "endFilename: ", `endFilename`, " startFilename: ", `filename`
     doAssert `endFilename` == `filename`, """
     Code from two different files were found in the same nbCode!
     If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 

From cbed8e8dc792c36505ff7b8fa50d294f2b106fb8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 11:33:08 +0100
Subject: [PATCH 45/73] add debug log to sources

---
 src/nimib/sources.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 81a3ef6..ad32e8e 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -20,7 +20,7 @@ proc `<`*(p1, p2: Pos): bool =
   doAssert p1.filename == p2.filename, """
   Code from two different files were found in the same nbCode!
   If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 
-  If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example."""
+  If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example.""" & " p1: " & p1.filename & " p2: " & p2.filename
   (p1.line, p1.column) < (p2.line, p2.column)
 
 proc toPos*(info: LineInfo): Pos =

From 29b018bb218418f8e0d62c586011c3e390c45526 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 11:43:58 +0100
Subject: [PATCH 46/73] more debug prints

---
 src/nimib/sources.nim | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index ad32e8e..1d4a5f1 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -27,6 +27,7 @@ proc toPos*(info: LineInfo): Pos =
   Pos(line: info.line, column: info.column, filename: info.filename)
 
 proc startPos(node: NimNode): Pos =
+  echo "startPos: ", node.repr
   case node.kind
   of nnkStmtList:
     return node[0].startPos()

From f1c4eb4e1a930a43a403674b41334d3c14d302d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 11:55:22 +0100
Subject: [PATCH 47/73] more debug

---
 src/nimib/sources.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 1d4a5f1..50e4512 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -27,7 +27,7 @@ proc toPos*(info: LineInfo): Pos =
   Pos(line: info.line, column: info.column, filename: info.filename)
 
 proc startPos(node: NimNode): Pos =
-  echo "startPos: ", node.repr
+  echo "startPos: ", node.repr, " treerepr: ", node.treerepr
   case node.kind
   of nnkStmtList:
     return node[0].startPos()

From f822034b36b903429b21b4728c3726e623362ee4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 22 Feb 2025 12:04:24 +0100
Subject: [PATCH 48/73] one last try

---
 src/nimib/sources.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 50e4512..eb670be 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -36,7 +36,7 @@ proc startPos(node: NimNode): Pos =
     for child in node.children:
       let childPos = child.startPos()
       # If we can't get the line info for some reason, skip it!
-      if childPos.line == 0: continue
+      if childPos.line == 0 or result.filename != childPos.filename: continue
       
       if childPos < result:
         result = childPos

From becf8183b697a4390593e569b43f838f3e9af265 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 13:02:23 +0100
Subject: [PATCH 49/73] try handling empty nimnodes

---
 src/nimib/sources.nim | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index eb670be..297ae40 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -34,9 +34,10 @@ proc startPos(node: NimNode): Pos =
   else:
     result = toPos(node.lineInfoObj())
     for child in node.children:
+      if child.kind == nnkEmpty: continue
       let childPos = child.startPos()
       # If we can't get the line info for some reason, skip it!
-      if childPos.line == 0 or result.filename != childPos.filename: continue
+      if childPos.line == 0: continue
       
       if childPos < result:
         result = childPos

From 6a5b4551a9e069d5122d6e4f0e30252f8d589507 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 13:13:02 +0100
Subject: [PATCH 50/73] remove debug prints in sources.nim

---
 src/nimib/sources.nim | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 297ae40..0874b04 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -20,14 +20,13 @@ proc `<`*(p1, p2: Pos): bool =
   doAssert p1.filename == p2.filename, """
   Code from two different files were found in the same nbCode!
   If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 
-  If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example.""" & " p1: " & p1.filename & " p2: " & p2.filename
+  If you are not mixing code from different files, please open an issue on nimib's Github with a minimal reproducible example."""
   (p1.line, p1.column) < (p2.line, p2.column)
 
 proc toPos*(info: LineInfo): Pos =
   Pos(line: info.line, column: info.column, filename: info.filename)
 
 proc startPos(node: NimNode): Pos =
-  echo "startPos: ", node.repr, " treerepr: ", node.treerepr
   case node.kind
   of nnkStmtList:
     return node[0].startPos()

From 78c20a72eb0e4850c94546387711a80bd499f5a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 18:36:51 +0100
Subject: [PATCH 51/73] cheatsheet is back!

---
 docsrc/cheatsheet.nim | 29 +++++++++++++++--------------
 nimib.nimble          |  2 +-
 src/nimib.nim         |  4 ++--
 3 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/docsrc/cheatsheet.nim b/docsrc/cheatsheet.nim
index cfa26fc..abc03a9 100644
--- a/docsrc/cheatsheet.nim
+++ b/docsrc/cheatsheet.nim
@@ -1,5 +1,5 @@
 ## Markdown cheatsheet with nimib 
-import nimib, std/strutils
+import nimib, std/[strutils, strformat]
 
 nbInit
 nbText: """
@@ -14,36 +14,37 @@ nbText: """
 > Quoted sections will be used to mention differences with the original source.
 """
 
-# is this block needed? for markdown, yes but hljs is already included!
 # customize source highlighting:
 nb.doc.context["highlight"] = %"""
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/styles/default.min.css">
 <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/highlight.min.js"></script>
 <script>hljs.initHighlightingOnLoad();</script>"""
 
+
 # a custom text block that shows markdown source
-template nbTextWithSource*(body: untyped) =
-  newNbBlock("nbTextWithSource", false, nb, nb.blk, body):
-    nb.blk.output = body
-  nb.blk.context["code"] = body
+newNbBlock(NbTextWithSource of NbText):
+  toHtml:
+    result = withNewlines:
+      nbTextToHtml(blk, nb)
+      &"""<pre><code class="language-markdown">{blk.text}</code></pre>"""
 
-nb.renderPlans["nbTextWithSource"] = @["mdOutputToHtml"]
-nb.partials["nbTextWithSource"] = """{{&outputToHtml}}
-<pre><code class=\"language-markdown\">{{code}}</code></pre>"""
+template nbTextWithSource*(body: string) =
+  let blk = newNbTextWithSource(text=body)
+  nb.add blk
 
 # how to add a ToC
 var
-  nbToc: NbBlock
+  nbToc: NbText
 
 template addToc =
-  newNbBlock("nbText", false, nb, nbToc, ""):
-    nbToc.output = "# Table of Contents:\n\n"
+  nbToc = newNbText(text="# Table of Contents:\n\n")
+  nb.add nbToc
 
 template nbSection(name:string) =
   let anchorName = name.toLower.replace(" ", "-")
   nbText "<a name = \"" & anchorName & "\"></a>\n# " & name & "\n\n---"
   # see below, but any number works for a numbered list
-  nbToc.output.add "1. <a href=\"#" & anchorName & "\">" & name & "</a>\n" 
+  nbToc.text.add "1. <a href=\"#" & anchorName & "\">" & name & "</a>\n" 
 
 # here is the start of the document
 nbText """
@@ -101,7 +102,7 @@ nbTextWithSource """1. First ordered list item
 * Unordered list can use asterisks
 - Or minuses
 + Or pluses"""
-nb.blk.output = nb.blk.output.replace(dot, " ")
+nb.blk.NbTextWithSource.text = nb.blk.NbTextWithSource.text.replace(dot, " ")
 
 nbText """
 > in ordered to have the ordered sublist work correctly
diff --git a/nimib.nimble b/nimib.nimble
index 1a2f2bb..51d08a4 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -29,7 +29,7 @@ task readme, "update readme":
 
 task docs, "Build documentation":
   for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
-    "pythno", "index"]: #, "cheatsheet", "files", "interactivity", "counters", "caesar"]:
+    "pythno", "index", "cheatsheet"]: #, "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
   #when not defined(nimibDocsSkipPenguins):
   #  exec "nim r --hints:off docsrc/penguins.nim"
diff --git a/src/nimib.nim b/src/nimib.nim
index 18d4efa..a2e1416 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -76,13 +76,13 @@ template nbInitMd*(thisFileRel = "") =
   if nb.options.filename == "":
     nb.doc.filename = nb.doc.filename.splitFile.name & ".md"
 
-# block generation templates
+#[ # block generation templates
 template newNbCodeBlock*(cmd: string, body, blockImpl: untyped) =
   newNbBlock(cmd, true, nb, nb.blk, body, blockImpl)
 
 template newNbSlimBlock*(cmd: string, blockImpl: untyped) =
   # a slim block is a block with no body
-  newNbBlock(cmd, false, nb, nb.blk, "", blockImpl)
+  newNbBlock(cmd, false, nb, nb.blk, "", blockImpl) ]#
 
 # block templates
 #[ template nbCode*(body: untyped) =

From bb473cf4ff89422ac82e31427635c94cab483dd5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 18:43:20 +0100
Subject: [PATCH 52/73] all docs are back!

---
 nimib.nimble          | 2 +-
 src/nimib/sources.nim | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/nimib.nimble b/nimib.nimble
index 51d08a4..71addf6 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -29,7 +29,7 @@ task readme, "update readme":
 
 task docs, "Build documentation":
   for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
-    "pythno", "index", "cheatsheet"]: #, "files", "interactivity", "counters", "caesar"]:
+    "pythno", "index", "cheatsheet", "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
   #when not defined(nimibDocsSkipPenguins):
   #  exec "nim r --hints:off docsrc/penguins.nim"
diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 0874b04..7b7c448 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -160,7 +160,6 @@ macro getCodeAsInSource*(source: string, body: untyped): string =
     if `filename` notin nb.doc.sourceFiles:
       nb.doc.sourceFiles[`filename`] = readFile(`filename`)
 
-    echo "endFilename: ", `endFilename`, " startFilename: ", `filename`
     doAssert `endFilename` == `filename`, """
     Code from two different files were found in the same nbCode!
     If you want to mix code from different files in nbCode, use -d:nimibCodeFromAst instead. 

From f44d11e154df32de1358f9fec8a1936b300cfaea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 19:20:29 +0100
Subject: [PATCH 53/73] include penguins in docs again

---
 docsrc/cheatsheet.nim | 2 +-
 docsrc/nolan.nim      | 2 +-
 docsrc/numerical.nim  | 2 +-
 nimib.nimble          | 4 ++--
 src/nimib.nim         | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/docsrc/cheatsheet.nim b/docsrc/cheatsheet.nim
index abc03a9..ddb1fdb 100644
--- a/docsrc/cheatsheet.nim
+++ b/docsrc/cheatsheet.nim
@@ -1,5 +1,5 @@
 ## Markdown cheatsheet with nimib 
-import nimib, std/[strutils, strformat]
+import nimib, std/[strutils, strformat, json]
 
 nbInit
 nbText: """
diff --git a/docsrc/nolan.nim b/docsrc/nolan.nim
index 8b57456..0226cb9 100644
--- a/docsrc/nolan.nim
+++ b/docsrc/nolan.nim
@@ -1,5 +1,5 @@
 import nimib
-import strutils, sequtils, strformat
+import strutils, sequtils, strformat, json
 
 nbInit
 nbText: """
diff --git a/docsrc/numerical.nim b/docsrc/numerical.nim
index 7814e77..5708efd 100644
--- a/docsrc/numerical.nim
+++ b/docsrc/numerical.nim
@@ -1,5 +1,5 @@
 #remember to run also with -d:numericalDefaultStyle
-import nimib, strformat, strutils
+import nimib, strformat, strutils, json
 nbInit
 nb.useLatex
 let
diff --git a/nimib.nimble b/nimib.nimble
index 71addf6..38ac5df 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -31,6 +31,6 @@ task docs, "Build documentation":
   for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
     "pythno", "index", "cheatsheet", "files", "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
-  #when not defined(nimibDocsSkipPenguins):
-  #  exec "nim r --hints:off docsrc/penguins.nim"
+  when not defined(nimibDocsSkipPenguins):
+    exec "nim r --hints:off docsrc/penguins.nim"
   #exec "nimble readme"  
diff --git a/src/nimib.nim b/src/nimib.nim
index a2e1416..f1d2284 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -3,7 +3,7 @@ import std / jsonutils except toJson
 export jsonutils except toJson
 import markdown
 import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons, json
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons
 # types exports mustache, tables, paths
 
 from nimib / themes import nil

From 32be620287b7e3d1effca5ef495113e1b00c533c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 23 Feb 2025 19:32:49 +0100
Subject: [PATCH 54/73] installblas

---
 .github/workflows/netlify_build_docs.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/netlify_build_docs.yml b/.github/workflows/netlify_build_docs.yml
index 1fd789a..b1d4320 100644
--- a/.github/workflows/netlify_build_docs.yml
+++ b/.github/workflows/netlify_build_docs.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: apt install
-        run: sudo apt install -y libpcre3
+        run: sudo apt install -y libpcre3 libblas-dev liblapack-dev
       - uses: actions/checkout@v2
       - name: install nim
         id: install_nim

From dc7a583f93257b543ca8fde4c1934ee0119d556a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 2 Mar 2025 17:55:14 +0100
Subject: [PATCH 55/73] implement partials and try it out on NbCode

---
 src/nimib.nim         | 11 +++++------
 src/nimib/renders.nim | 26 ++++++++++++++++++++++++++
 src/nimib/types.nim   |  2 ++
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index f1d2284..5db5441 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -9,7 +9,8 @@ export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources
 from nimib / themes import nil
 export themes.useLatex, themes.darkMode, themes.`title=`, themes.disableHighlightJs
 
-from nimib / renders import nil
+#from nimib / renders import nil
+import nimib / renders
 
 from mustachepkg/values import searchTable, searchDirs, castStr
 export searchTable, searchDirs, castStr
@@ -95,12 +96,10 @@ newNbBlock(NbCode of NbContainer):
   output: string
   toHtml:
     withNewlines:
-      # TODO: highlight code statically
-      if blk.code.len > 0:
-        &"<pre><code class=\"nohighlight hljs nim\">{blk.code.highlightNim}</code></pre>"
+      nb.renderPartial("nbCodeSource", jsonutils.toJson(blk))
       nbContainerToHtml(blk, nb)
-      if blk.output.len > 0:
-        &"<pre class=\"nb-output\">{blk.output}</pre>"
+      nb.renderPartial("nbCodeOutput", jsonutils.toJson(blk))
+      
 
 template code*(nb: Nb, body: untyped) =
   let blk = newNbCode()
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index d9dd2f7..ea77927 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -10,6 +10,15 @@ import mustachepkg/values
 proc highlightCode(doc: var NbDoc, blk: var NbBlock) =
   blk.context["codeHighlighted"] = highlightNim(blk.code) ]#
 
+func renderPartial*(render: NbRender, name: string, blk: JsonNode, nb: Nb): string =
+  if name in render.partials:
+    render.partials[name](blk, nb)
+  else:
+    ""
+
+func renderPartial*(nb: Nb, name: string, blk: JsonNode): string =
+  nb.backend.renderPartial(name, blk, nb)
+
 func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   let doc = blk.NbDoc
   result = withNewlines:
@@ -28,6 +37,23 @@ func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
 addNbBlockToJson(NbDoc) # should this be here?
 nbToHtml.funcs["NbDoc"] = nbDocToHtml
 
+func nbCodeSourcePartial*(blk: JsonNode, nb: Nb): string =
+  let code = blk{"code"}.getStr
+  if code.len > 0:
+    &"<pre><code class=\"nohighlight hljs nim\">{code.highlightNim}</code></pre>"
+  else:
+    ""
+
+nbToHtml.partials["nbCodeSource"] = nbCodeSourcePartial
+
+func nbCodeOutputPartial*(blk: JsonNode, nb: Nb): string =
+  let output = blk{"output"}.getStr
+  if output.len > 0:
+    &"<pre class=\"nb-output\">{output}</pre>"
+  else:
+    ""
+
+nbToHtml.partials["nbCodeOutput"] = nbCodeOutputPartial
 
 
 proc useHtmlBackend*(doc: var NbDoc) =
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index 5fb8e96..b2545f5 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -13,8 +13,10 @@ type
   NbConfig* = object
     srcDir*, homeDir*: string
   NbRenderFunc* = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
+  NbPartialFunc* = proc (blk: JsonNode, nb: Nb): string {. noSideEffect .}
   NbRender* = ref object of RootObj
     funcs*: Table[string, NbRenderFunc]
+    partials*: Table[string, NbPartialFunc]
   NbContainer* = ref object of NbBlock
     blocks*: seq[NbBlock]
   NbDoc* = ref object of NbContainer

From b775b0aefa478bc77126c3cf285679c987725e43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 2 Mar 2025 20:18:47 +0100
Subject: [PATCH 56/73] remove showCode field from NbJs blocks as it isn't used
 anymore

---
 src/nimib/jsutils.nim | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/nimib/jsutils.nim b/src/nimib/jsutils.nim
index d83a984..9cd5ec5 100644
--- a/src/nimib/jsutils.nim
+++ b/src/nimib/jsutils.nim
@@ -1,28 +1,21 @@
 import std / [macros, macrocache, tables, strutils, strformat, sequtils, sugar, os, hashes]
-import ./types, ./nimibSugars, ./globals, ./jsons, ./blocks
+import ./types, ./nimibSugars, ./globals, ./jsons, ./blocks, ./renders
+from std/jsonutils import nil
 
 
 newNbBlock(NbJsFromCode): # should inherit from nbCode, but it is defined in nimib.nim...
   code: string
   transformedCode: string
   putAtTop: bool
-  showCode: bool
   toHtml:
-    if blk.showCode:
-      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
-    else:
-      ""
+    ""
 
 newNbBlock(NbJsFromCodeOwnFile):
   code: string
   transformedCode: string
   jsCode: string
-  showCode: bool
   toHtml:
-    withNewlines:
-      if blk.showCode:
-        "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
-      &"<script>\n{blk.jsCode}\n</script>"
+    &"<script>\n{blk.jsCode}\n</script>"
 
 proc contains(tab: CacheTable, keyToCheck: string): bool =
   for key, val in tab:
@@ -295,7 +288,7 @@ proc nbCollectAllNbJs*(nb: var Nb) =
 
   if not code.isEmptyOrWhitespace:
     # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
-    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
+    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code)
     nb.add blk
 
   # loop over all nbJsFromCodeOwnFile and compile them

From bef739a0f76ddb7735bca91771bdf525c5241370 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 2 Mar 2025 20:19:32 +0100
Subject: [PATCH 57/73] nbText now uses partial

---
 src/nimib.nim         |  3 +--
 src/nimib/renders.nim | 10 ++++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 5db5441..e553943 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -165,8 +165,7 @@ template nimibCode*(body: untyped) =
 newNbBlock(NbText):
   text: string
   toHtml:
-    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-      markdown(blk.text, config=initGfmConfig())
+    nb.renderPartial("nbText", jsonutils.toJson(blk))
 
 func text*(nb: var Nb, text: string) =
   let blk = newNbText(text=text)
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index ea77927..2f56bd5 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -55,6 +55,16 @@ func nbCodeOutputPartial*(blk: JsonNode, nb: Nb): string =
 
 nbToHtml.partials["nbCodeOutput"] = nbCodeOutputPartial
 
+func markdownToHtml*(markdownText: string): string =
+  {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
+    markdown(markdownText, config=initGfmConfig())
+
+func nbTextPartial*(blk: JsonNode, nb: Nb): string =
+  let text = blk{"text"}.getStr
+  markdownToHtml(text)
+
+nbToHtml.partials["nbText"] = nbTextPartial
+
 
 proc useHtmlBackend*(doc: var NbDoc) =
   discard

From 83fe356d691fa7b31f8ef5d503f89f7174c9f8c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 14 Mar 2025 16:41:36 +0100
Subject: [PATCH 58/73] use partials for rendering NbDoc

---
 src/nimib.nim         |   3 +-
 src/nimib/renders.nim |  38 +++++++-----
 src/nimib/themes.nim  | 137 +++++++++++++++++++++---------------------
 src/nimib/types.nim   |   9 +++
 4 files changed, 105 insertions(+), 82 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index e553943..6607991 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -64,7 +64,7 @@ template nbInit*(theme = themes.useDefault, renderer: NbRender = nbToHtml, thisF
   nb.backend = renderer
 
   # apply theme
-  theme nb.doc # how do we handle themes?
+  theme nb # how do we handle themes?
 
 template nbInitMd*(thisFileRel = "") = 
   var tfr = if thisFileRel == "":
@@ -239,6 +239,7 @@ newNbBlock(NbFile):
 <pre>{blk.filename}</pre>
 <pre><code class="{blk.ext} hljs">{blk.content}</code></pre>
 """
+# Make pre-code with hljs-extensions into a partial! Or a function that calls a partial even? (that constructs the JsNode for us)
 
 proc file*(nb: var Nb, tname: string, tcontent: string) =
   ## Generic string file
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index 2f56bd5..0d505ac 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -3,6 +3,7 @@ import ./types, markdown, mustache, ./jsutils, ./nimibSugars, ./themes, ./global
 
 import highlight
 import mustachepkg/values
+from std/jsonutils import nil
 
 #[ proc mdOutputToHtml(doc: var NbDoc, blk: var NbBlock) =
   blk.context["outputToHtml"] = markdown(blk.output, config=initGfmConfig()).dup(removeSuffix)
@@ -10,29 +11,21 @@ import mustachepkg/values
 proc highlightCode(doc: var NbDoc, blk: var NbBlock) =
   blk.context["codeHighlighted"] = highlightNim(blk.code) ]#
 
-func renderPartial*(render: NbRender, name: string, blk: JsonNode, nb: Nb): string =
-  if name in render.partials:
-    render.partials[name](blk, nb)
-  else:
-    ""
-
-func renderPartial*(nb: Nb, name: string, blk: JsonNode): string =
-  nb.backend.renderPartial(name, blk, nb)
 
 func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
   let doc = blk.NbDoc
+  let docJson = %[] # it's unused
   result = withNewlines:
     "<!DOCTYPE html>"
     """<html lang="en-us">"""
-    headToHtml(doc)
+    nb.renderPartial("head", docJson)
     "<body>"
-    headerToHtml(doc)
-    leftToHtml()
+    nb.renderPartial("header", docJson)
+    nb.renderPartial("left", docJson)
     mainToHtml(doc, nb)
-    rightToHtml()
-    footerToHtml(doc)
+    nb.renderPartial("right", docJson)
+    nb.renderPartial("footer", docJson)
     "</body>"
-  # TODO: Convert all constants below into functions with inputs!
 
 addNbBlockToJson(NbDoc) # should this be here?
 nbToHtml.funcs["NbDoc"] = nbDocToHtml
@@ -120,6 +113,23 @@ Your browser does not support the audio element.
   doc.renderProcs["highlightCode"] = highlightCode
   doc.renderProcs["compileNimToJs"] = compileNimToJs ]#
 
+#[ func nbDocToMd*(blk: NbBlock, nb: Nb): string =
+  let doc = blk.NbDoc
+  result = nbContainerToHtml(doc, nb)
+
+nbToMd.funcs["NbDoc"] = nbDocToMd
+
+proc nbTextToMd*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbText
+
+nbToMd.funcs["NbText"] = nbTextToMd
+
+proc nbCodeToMd*(blk: NbBlock, nb: Nb): string =
+  discard
+
+nbToMd.funcs["NbCode"] = nbCodeToMd ]#
+
+
 proc useMdBackend*(doc: var NbDoc) =
   discard
 #[
diff --git a/src/nimib/themes.nim b/src/nimib/themes.nim
index 4d6d8c4..1e4d148 100644
--- a/src/nimib/themes.nim
+++ b/src/nimib/themes.nim
@@ -12,21 +12,21 @@ func getTitle*(doc: NbDoc): string =
 
 
 # All of this should be moved to renders.nim?
-func headToHtml*(doc: NbDoc): string =
+func headToHtml*(blk: JsonNode, nb: Nb): string =
   result = withNewlines:
     fmt"""
 <head>
-  <title>{doc.getTitle}</title>
+  <title>{nb.doc.getTitle}</title>
   <meta content="text/html; charset=utf-8" http-equiv="content-type">
   <meta content="width=device-width, initial-scale=1" name="viewport">
-  <meta content="nimib {doc.context.getOrDefault("version").getStr}" name="generator">
-  {doc.context.getOrDefault("stylesheet").getStr}
-  {doc.context.getOrDefault("highlight").getStr}
-  {doc.context.getOrDefault("nb_style").getStr}
-  {doc.context.getOrDefault("latex").getStr}
+  <meta content="nimib {nb.doc.context.getOrDefault("version").getStr}" name="generator">
+  {nb.doc.context.getOrDefault("stylesheet").getStr}
+  {nb.doc.context.getOrDefault("highlight").getStr}
+  {nb.doc.context.getOrDefault("nb_style").getStr}
+  {nb.doc.context.getOrDefault("latex").getStr}
     """
-    if not doc.context{"disableHighlightJs"}.getBool(false):
-      doc.context{"highlightJs"}.getStr
+    if not nb.doc.context{"disableHighlightJs"}.getBool(false):
+      nb.doc.context{"highlightJs"}.getStr
     "</head>"
     
 
@@ -36,31 +36,31 @@ func madeWithNimibToHtml*(): string =
 func homeLinkToHtml*(homePath: string): string =
   fmt"""<a href="{homePath}">🏡</a>"""
 
-func headerLeftToHtml*(doc: NbDoc): string =
-  homeLinkToHtml(doc.context{"path_to_root"}.getStr("/"))
+func headerLeftToHtml*(blk: JsonNode, nb: Nb): string =
+  homeLinkToHtml(nb.doc.context{"path_to_root"}.getStr("/"))
 
-func headerCenterToHtml*(doc: NbDoc): string =
-  let title = doc.getTitle()
+func headerCenterToHtml*(blk: JsonNode, nb: Nb): string =
+  let title = nb.doc.getTitle()
   fmt"<code>{title}</code>"
 
-func headerRightToHtml*(doc: NbDoc): string =
-  if not isNil(doc.context{"github_remote_url"}):
-    let githubRemoteUrl = doc.context{"github_remote_url"}.getStr
-    let githubLogo = doc.context{"github_logo"}.getStr(githubLogoLight)
+func headerRightToHtml*(blk: JsonNode, nb: Nb): string =
+  if not isNil(nb.doc.context{"github_remote_url"}):
+    let githubRemoteUrl = nb.doc.context{"github_remote_url"}.getStr
+    let githubLogo = nb.doc.context{"github_logo"}.getStr(githubLogoLight)
     result = fmt"""<a href="{github_remote_url}">{github_logo}</a>"""
 
-func headerToHtml*(doc: NbDoc): string =
+func headerToHtml*(blk: JsonNode, nb: Nb): string =
   result = withNewlines:
     "<header>"
     """<div class="nb-box">"""
-    " <span>" & headerLeftToHtml(doc) & "</span>"
-    " <span>" & headerCenterToHtml(doc) & "</span>"
-    " <span>" & headerRightToHtml(doc) & "</span>"
+    " <span>" & nb.renderPartial("header_left", blk) & "</span>"
+    " <span>" & nb.renderPartial("header_center", blk) & "</span>"
+    " <span>" & nb.renderPartial("header_right", blk) & "</span>"
     "</div>"
     "<hr>"
     "</header>"
 
-func leftToHtml*(): string =
+func leftToHtml*(blk: JsonNode, nb: Nb): string =
   ""
 
 func mainToHtml*(blk: NbBlock, nb: Nb): string =
@@ -69,29 +69,29 @@ func mainToHtml*(blk: NbBlock, nb: Nb): string =
     nbContainerToHtml(blk, nb)
     "</main>"
 
-func rightToHtml*(): string =
+func rightToHtml*(blk: JsonNode, nb: Nb): string =
   ""
 
-func footerLeftToHtml*(): string =
+func footerLeftToHtml*(blk: JsonNode, nb: Nb): string =
   madeWithNimibToHtml()
 
-func footerCenterToHtml*(): string =
+func footerCenterToHtml*(blk: JsonNode, nb: Nb): string =
   ""
 
-func showSourceButtonToHtml*(): string =
+func showSourceButtonToHtml*(blk: JsonNode, nb: Nb): string =
   """<button class="nb-small" id="show" onclick="toggleSourceDisplay()">Show Source</button>"""
 
-func footerRightToHtml*(): string =
-  showSourceButtonToHtml()
+func footerRightToHtml*(blk: JsonNode, nb: Nb): string =
+  showSourceButtonToHtml(blk, nb)
 
-func sourceSectionToHtml*(doc: NbDoc): string =
+func sourceSectionToHtml*(blk: JsonNode, nb: Nb): string =
   fmt"""
 <section id="source">
-<pre><code class="nohighlight nim hljs">{doc.context.getOrDefault("source_highlighted").getStr}</code></pre>
+<pre><code class="nohighlight nim hljs">{nb.doc.context.getOrDefault("source_highlighted").getStr}</code></pre>
 </section>
   """
 
-func showSourceScriptToHtml*(): string =
+func showSourceScriptToHtml*(blk: JsonNode, nb: Nb): string =
   """
 <script>
   function toggleSourceDisplay() {
@@ -108,18 +108,18 @@ func showSourceScriptToHtml*(): string =
 </script>
   """
 
-func footerToHtml*(doc: NbDoc): string =
-  fmt"""
-<footer>
-<div class="nb-box">
-  <span>{footerLeftToHtml()}</span>
-  <span>{footerCenterToHtml()}</span>
-  <span>{footerRightToHtml()}</span>
-</div>
-</footer>
-{sourceSectionToHtml(doc)}
-{showSourceScriptToHtml()}
-  """
+func footerToHtml*(blk: JsonNode, nb: Nb): string =
+  result = withNewlines:
+    "<footer>"
+    """<div class="nb-box">"""
+    " <span>" & nb.renderPartial("footer_left", blk) & "</span>"
+    " <span>" & nb.renderPartial("footer_center", blk) & "</span>"
+    " <span>" & nb.renderPartial("footer_right", blk) & "</span>"
+    "</div>"
+    "</footer>"
+    nb.renderPartial("source_section", blk)
+    nb.renderPartial("show_source_script", blk)
+
 
 #[ # TODO: Make these old partials into procs with inputs so they can be reused!
 const document* = """
@@ -251,37 +251,40 @@ function toggleSourceDisplay() {
 proc optOut*(content, keyword: string): string =
   "{{^" & keyword & "}}" & content & "{{/" & keyword & "}}" ]#
 
-proc useDefault*(doc: var NbDoc) =
-  doc.context["path_to_root"] = %(doc.srcDirRel).string
-  doc.context["path_to_here"] = %(doc.thisFileRel).string
-  doc.context["source"] = %doc.source
+proc useDefault*(nb: var Nb) =
+  nb.doc.context["path_to_root"] = %(nb.doc.srcDirRel).string
+  nb.doc.context["path_to_here"] = %(nb.doc.thisFileRel).string
+  nb.doc.context["source"] = %nb.doc.source
 
   #doc.partials["document"] = document
   #doc.partials["main"] = main
+  nb.backend.partials["left"] = leftToHtml
+  nb.backend.partials["right"] = rightToHtml
   # head
-  #doc.partials["head"] = head
-  doc.context["version"] = %getNimibVersion()
-  doc.context["favicon"] = %faviconWhale
-  doc.context["stylesheet"] = %waterLight
-  doc.context["highlight"] = %atomOneLight
-  doc.context["highlightJs"] = %highlightJsTags
-  doc.context["nb_style"] = %nbStyle
+  nb.backend.partials["head"] = headToHtml
+  nb.doc.context["version"] = %getNimibVersion()
+  nb.doc.context["favicon"] = %faviconWhale
+  nb.doc.context["stylesheet"] = %waterLight
+  nb.doc.context["highlight"] = %atomOneLight
+  nb.doc.context["highlightJs"] = %highlightJsTags
+  nb.doc.context["nb_style"] = %nbStyle
   # header
-  #doc.partials["header"] = header
-  #doc.partials["header_left"] = homeLink
-  doc.context["title"] = doc.context["path_to_here"]
-  #doc.partials["header_center"] = "<code>" & doc.context["title"].castStr & "</code>"
+  nb.backend.partials["header"] = headerToHtml
+  nb.backend.partials["header_left"] = headerLeftToHtml
+  nb.doc.context["title"] = nb.doc.context["path_to_here"]
+  nb.backend.partials["header_center"] = headerCenterToHtml
   if isGitAvailable() and isOnGithub():
-    #doc.partials["header_right"] = githubLink
-    doc.context["github_remote_url"] = %getGitRemoteUrl()
-    doc.context["github_logo"] = %githubLogoLight
+    nb.backend.partials["header_right"] = headerRightToHtml
+    nb.doc.context["github_remote_url"] = %getGitRemoteUrl()
+    nb.doc.context["github_logo"] = %githubLogoLight
   # footer
-  # doc.partials["footer"] = footer
-  # doc.partials["footer_left"] = madeWithNimib
-  # doc.partials["footer_right"] = optOut(showSourceButton, "no_source")
-  # doc.partials["source_section"] = optOut(sourceSection, "no_source")
-  # doc.partials["show_source_script"] = optOut(showSourceScript, "no_source")
-  doc.context["source_highlighted"] = %highlightNim(doc.context["source"].getStr)
+  nb.backend.partials["footer"] = footerToHtml
+  nb.backend.partials["footer_left"] = footerLeftToHtml
+  nb.backend.partials["footer_center"] = footerCenterToHtml
+  nb.backend.partials["footer_right"] = footerRightToHtml
+  nb.backend.partials["source_section"] = sourceSectionToHtml
+  nb.backend.partials["show_source_script"] = showSourceScriptToHtml
+  nb.doc.context["source_highlighted"] = %highlightNim(nb.doc.context["source"].getStr)
 
 proc darkMode*(doc: var NbDoc) =
   doc.context["stylesheet"] = %waterDark
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index b2545f5..14841de 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -72,6 +72,15 @@ func render*(nb: Nb, blk: NbBlock): string =
   else:
     ""
 
+func renderPartial*(render: NbRender, name: string, blk: JsonNode, nb: Nb): string =
+  if name in render.partials:
+    render.partials[name](blk, nb)
+  else:
+    ""
+
+func renderPartial*(nb: Nb, name: string, blk: JsonNode): string =
+  nb.backend.renderPartial(name, blk, nb)
+
 func nbContainerToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbContainer
   for b in blk.blocks:

From 5bf0a5cbaf702345bf7a6c97bd203a7afb3dd8dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sun, 18 May 2025 10:45:33 +0200
Subject: [PATCH 59/73] implement NbDiv

---
 src/nimib.nim | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index 6607991..adc6973 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -18,7 +18,7 @@ export searchTable, searchDirs, castStr
 template moduleAvailable*(module: untyped): bool =
   (compiles do: import module)
 
-template nbInit*(theme = themes.useDefault, renderer: NbRender = nbToHtml, thisFileRel = "") =
+template nbInit*(theme: proc (nb: var Nb) = themes.useDefault, renderer: NbRender = nbToHtml, thisFileRel = "") =
   var nb {.inject.}: Nb
   nb.doc = NbDoc(kind: "NbDoc")
   nb.doc.initDir = getCurrentDir().AbsoluteDir
@@ -393,6 +393,25 @@ func show*[T](nb: var Nb, obj: T) =
 template nbShow*(obj: untyped) =
   nb.show(obj)
 
+newNbBlock(NbDiv of NbContainer):
+  class: string
+  style: string
+  toHtml:
+    withNewLines:
+      &"<div class=\"{blk.class}\" style=\"{blk.style}\">"
+      nbContainerToHtml(blk, nb)
+      "</div>"
+
+template nbDiv*(classes: string, styles: string, body: untyped) =
+  let blk = newNbDiv(class=classes, style=styles)
+  nb.withContainer(blk):
+    body
+  nb.add blk
+
+template nbDiv*(body: untyped) =
+  nbDiv("", ""):
+    body
+
 #[ template nbShow*(obj: untyped) =
   nbRawHtml(obj.toHtml())
 

From ef27371ee67b0771f89d90660451914563a1d5ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 17 Oct 2025 14:17:30 +0200
Subject: [PATCH 60/73] tblocks.nim now working

---
 tests/tblocks.nim | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/tests/tblocks.nim b/tests/tblocks.nim
index 8ec6b69..8f1cc2f 100644
--- a/tests/tblocks.nim
+++ b/tests/tblocks.nim
@@ -1,28 +1,22 @@
 import nimib
 import std / [unittest, strutils]
 
+newNbBlock(ReadCodeBlock):
+  code: string
+  toHtml:
+    blk.code
+
 suite "newNbBlock":
   nbInit
-  var blk: NbBlock
   test "readCode":
     template readCodeBlock(body: untyped) =
-      newNbBlock("readCodeBlock", true, nb, blk):
-        body
-      do:
-        discard
+      let blk = newReadCodeBlock()
+      blk.code = getCode(body)
+      nb.add blk
 
-    template dontReadCodeBlock(body: untyped) =
-      newNbBlock("dontReadCodeBlock", false, nb, blk):
-        body
-      do:
-        discard
-    
     readCodeBlock:
       let a = 1.23
-    check blk.code == "let a = 1.23"
 
-    dontReadCodeBlock:
-      let b = 3.21
-    check blk.code == ""
+    check nb.blk.ReadCodeBlock.code == "let a = 1.23\n"
 
 

From a94102fa835fd333f084776ebc5b1865252a5b77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Fri, 17 Oct 2025 15:16:17 +0200
Subject: [PATCH 61/73] fix tnimib.nim

---
 tests/tnimib.nim | 238 +++++++++++++++++++++++------------------------
 1 file changed, 117 insertions(+), 121 deletions(-)

diff --git a/tests/tnimib.nim b/tests/tnimib.nim
index ea791c3..4825f41 100644
--- a/tests/tnimib.nim
+++ b/tests/tnimib.nim
@@ -7,18 +7,18 @@ nbInit # todo: add a test suite for nbInit
 suite "nbText":
   test "single line text string":
     nbText: "hi"
-    check nb.blk.output == "hi"
+    check nb.blk.NbText.text == "hi"
 
   test "single line text string with strformat":
     let name = "you"
     nbText: fmt"hi {name}"
-    check nb.blk.output == "hi you"
+    check nb.blk.NbText.text == "hi you"
 
   test "multi line text string":
     nbText: """hi
 how are you?
 """
-    check nb.blk.output == """hi
+    check nb.blk.NbText.text == """hi
 how are you?
 """
 
@@ -29,29 +29,29 @@ how are you?
     nbText: &"""hi {name}
 how are you? {answer}
 """
-    check nb.blk.output == """hi you
+    check nb.blk.NbText.text == """hi you
 how are you? fine
 """
 
 suite "nbTextWithCode":
   test "single line text string":
     nbTextWithCode: "hi"
-    check nb.blk.code == "\"hi\""
-    check nb.blk.output == "hi"
+    check nb.blk.NbTextWithCode.code == "\"hi\""
+    check nb.blk.NbTextWithCode.text == "hi"
 
   test "single line text string with strformat":
       let name = "you"
       nbTextWithCode: fmt"hi {name}"
-      check nb.blk.code == "fmt\"hi {name}\""
-      check nb.blk.output == "hi you"
+      check nb.blk.NbTextWithCode.code == "fmt\"hi {name}\""
+      check nb.blk.NbTextWithCode.text == "hi you"
 
   test "multi line text string - variant 1":
     nbTextWithCode:
       """hi
 how are you?
 """
-    check nb.blk.code == "\"\"\"hi\nhow are you?\n\"\"\""
-    check nb.blk.output == """hi
+    check nb.blk.NbTextWithCode.code == "\"\"\"hi\nhow are you?\n\"\"\""
+    check nb.blk.NbTextWithCode.text == """hi
 how are you?
 """
 
@@ -62,10 +62,10 @@ hi
 how are you?
 """
     when defined(nimibCodeFromAst):
-      check nb.blk.code == "\"\"\"hi\nhow are you?\n\"\"\""
+      check nb.blk.NbTextWithCode.code == "\"\"\"hi\nhow are you?\n\"\"\""
     else:
-      check nb.blk.code == "\"\"\"\nhi\nhow are you?\n\"\"\""
-    check nb.blk.output == """hi
+      check nb.blk.NbTextWithCode.code == "\"\"\"\nhi\nhow are you?\n\"\"\""
+    check nb.blk.NbTextWithCode.text == """hi
 how are you?
 """
 
@@ -73,8 +73,8 @@ how are you?
     nbTextWithCode: """hi
 how are you?
 """
-    check nb.blk.code == "\"\"\"hi\nhow are you?\n\"\"\""
-    check nb.blk.output == """hi
+    check nb.blk.NbTextWithCode.code == "\"\"\"hi\nhow are you?\n\"\"\""
+    check nb.blk.NbTextWithCode.text == """hi
 how are you?
 """
 
@@ -85,32 +85,30 @@ how are you?
     nbTextWithCode: &"""hi {name}
 how are you? {answer}
 """
-    check nb.blk.code == "&\"\"\"hi {name}\nhow are you? {answer}\n\"\"\""
-    check nb.blk.output == """hi you
+    check nb.blk.NbTextWithCode.code == "&\"\"\"hi {name}\nhow are you? {answer}\n\"\"\""
+    check nb.blk.NbTextWithCode.text == """hi you
 how are you? fine
 """
 
 suite "nbCode":
   test "single line of code, no output":
     nbCode: discard
-    check nb.blk.code == "discard"
-    check nb.blk.output == ""
+    check nb.blk.NbCode.code == "discard"
+    check nb.blk.NbCode.output == ""
 
   test "single line of code, with output":
     nbCode: echo "hi"
-    check nb.blk.code == "echo \"hi\""
-    check nb.blk.output == "hi\n"
+    check nb.blk.NbCode.code == "echo \"hi\""
+    check nb.blk.NbCode.output == "hi\n"
 
 suite "nbRawHtml":
   test "pure text":
     nbRawHtml: "Hello world!"
-    check nb.blk.code == ""
-    check nb.blk.output == "Hello world!"
+    check nb.blk.NbRawHtml.html == "Hello world!"
   
   test "html tags":
     nbRawHtml: "<div> <span> div-span </span> </div>"
-    check nb.blk.code == ""
-    check nb.blk.output == "<div> <span> div-span </span> </div>"
+    check nb.blk.NbRawHtml.html == "<div> <span> div-span </span> </div>"
 
   test "Use inside template":
     # codeAsInSource can't read the correct line if block is used inside a template
@@ -121,29 +119,25 @@ suite "nbRawHtml":
       nbRawHtml: "</slide>"
     
     slide:
-      check nb.blk.code == ""
-      check nb.blk.output == "<slide>"
+      check nb.blk.NbRawHtml.html == "<slide>"
     
-    check nb.blk.code == ""
-    check nb.blk.output == "</slide>"
+    check nb.blk.NbRawHtml.html == "</slide>"
 
 suite "nbClearOutput":
   test "nbCode":
     nbCode:
       echo "Hello world!!!"
-    check nb.blk.output == "Hello world!!!\n"
-    check nb.blk.context["output"].vString == "Hello world!!!"
+    check nb.blk.NbCode.output == "Hello world!!!\n"
     nbClearOutput()
-    check nb.blk.output == ""
-    check nb.blk.context["output"].vString == ""
+    check nb.blk.NbCode.output == ""
 
 suite "nbCodeSkip":
   test "single line of code with output":
     nbCodeSkip:
       echo "random output..."
 
-    check nb.blk.output == ""
-    check nb.blk.code == "echo \"random output...\""
+    check nb.blk.NbCode.output == ""
+    check nb.blk.NbCode.code == "echo \"random output...\"\n"
 
   test "destructive code":
     # Make sure the code is NOT executed
@@ -151,21 +145,103 @@ suite "nbCodeSkip":
     nbCodeSkip:
       fail()
     
-    check nb.blk.output == ""
-    check nb.blk.code == "fail()"
+    check nb.blk.NbCode.output == ""
+    check nb.blk.NbCode.code == "fail()\n"
 
 suite "nbCapture":
   test "single line of code, with output":
     nbCapture:
       echo "captured output"
 
-    check nb.blk.output == "captured output\n"
+    check nb.blk.NbCode.output == "captured output\n"
 
   test "single line of code, without output":
     nbCapture:
       discard
 
-    check nb.blk.output == ""
+    check nb.blk.NbCode.output == ""
+
+
+suite "nbJs":
+  test "nbJsFromString":
+    nbJsFromString: hlNim"""
+let a = 1
+echo a
+"""
+    check nb.blk.NbJsFromCode.code == """
+let a = 1
+echo a
+"""
+    check nb.blk.NbJsFromCode.transformedCode.len > 0
+
+  test "nbJsFromCode":
+    nbJsFromCode:
+      let a = 1
+      echo a
+    check nb.blk.NbJsFromCode.transformedCode.len > 0
+    check "a = 1" in nb.blk.NbJsFromCode.transformedCode
+    check "block:" notin nb.blk.NbJsFromCode.transformedCode
+
+  test "nbJsFromCode, capture variable":
+    let a = 1
+    nbJsFromCode(a):
+      echo a
+    check nb.blk.NbJsFromCode.transformedCode.len > 0
+    check "a = parseJson" in nb.blk.NbJsFromCode.transformedCode
+
+  test "nbJsFromCodeGlobal":
+    nbJsFromCodeGlobal:
+      import std / dom
+      var x = 1
+    check nb.blk.NbJsFromCode.transformedCode.len > 0
+    check "x = 1" in nb.blk.NbJsFromCode.transformedCode
+    check "block:" notin nb.blk.NbJsFromCode.transformedCode
+
+  test "nbJsFromCodeInBlock":
+    nbJsFromCodeInBlock:
+      let x = 3.14
+      echo x
+    check nb.blk.NbJsFromCode.transformedCode.len > 0
+    check "x = 3.14" in nb.blk.NbJsFromCode.transformedCode
+    check "block:" in nb.blk.NbJsFromCode.transformedCode
+
+  test "nbJsFromCodeOwnFile + exportc":
+    nbJsFromCodeOwnFile:
+      proc setup() {.exportc.} =
+        echo 1
+    check "setup()" in nb.blk.NbJsFromCodeOwnFile.transformedCode
+
+  test "nbCodeDisplay":
+    nbCodeDisplay(nbJsFromCode):
+      import p5
+      echo "hi p5"
+      draw:
+        ellipse(mouseX, mouseY, 20)
+    check nb.blocks[^1].kind == "NbCode"
+    check nb.blocks[^2].kind == "NbJsFromCode"
+    check nb.blocks[^2].NbJsFromCode.transformedCode.len > 0
+    check "ellipse(mouseX, mouseY, 20)" in nb.blocks[^2].NbJsFromCode.transformedCode
+    when defined(nimibCodeFromAst):
+      check nb.blocks[^1].NbCode.code.startsWith("import\n  p5")
+    else:
+      check nb.blocks[^1].NbCode.code.startsWith("import p5")
+    check nb.blocks[^1].NbCode.output == ""
+
+  test "nbCodeAnd":
+    nbCodeAnd(nbJsFromCode):
+      let you = "me"
+      echo "hi ", you
+    check nb.blocks[^2].kind == "NbCode"
+    check nb.blocks[^1].kind == "NbJsFromCode"
+    check nb.blocks[^1].NbJsFromCode.transformedCode.len > 0
+    check "you = \"me\"" in nb.blocks[^1].NbJsFromCode.transformedCode
+    check nb.blocks[^2].NbCode.code.startsWith("let you =")
+    check nb.blocks[^2].NbCode.output == "hi me\n"
+
+test "getNimibVersion()":
+  let version = getNimibVersion()
+
+  check version.count('.') == 2
 
 when moduleAvailable(nimpy) and false:
   nbInitPython()
@@ -182,55 +258,7 @@ print(a)
       check nb.blk.output == "[0, 2, 4]\n3.14\n"
 
 when moduleAvailable(karax/kbase):
-  suite "nbJs":
-    test "nbJsFromString":
-      nbJsFromString: hlNim"""
-  let a = 1
-  echo a
-  """
-      check nb.blk.code == """
-  let a = 1
-  echo a
-  """
-      check nb.blk.context["transformedCode"].vString.len > 0
-
-    test "nbJsFromCode":
-      nbJsFromCode:
-        let a = 1
-        echo a
-      check nb.blk.context["transformedCode"].vString.len > 0
-      check "a = 1" in nb.blk.context["transformedCode"].vString
-      check "block:" notin nb.blk.context["transformedCode"].vString
-
-    test "nbJsFromCode, capture variable":
-      let a = 1
-      nbJsFromCode(a):
-        echo a
-      check nb.blk.context["transformedCode"].vString.len > 0
-      check "a = parseJson" in nb.blk.context["transformedCode"].vString
-
-    test "nbJsFromCodeGlobal":
-      nbJsFromCodeGlobal:
-        import std / dom
-        var x = 1
-      check nb.blk.context["transformedCode"].vString.len > 0
-      check "x = 1" in nb.blk.context["transformedCode"].vString
-      check "block:" notin nb.blk.context["transformedCode"].vString
-
-    test "nbJsFromCodeInBlock":
-      nbJsFromCodeInBlock:
-        let x = 3.14
-        echo x
-      check nb.blk.context["transformedCode"].vString.len > 0
-      check "x = 3.14" in nb.blk.context["transformedCode"].vString
-      check "block:" in nb.blk.context["transformedCode"].vString
-
-    test "nbJsFromCodeOwnFile + exportc":
-      nbJsFromCodeOwnFile:
-        proc setup() {.exportc.} =
-          echo 1
-      check "setup()" in nb.blk.context["transformedCode"].vString
-
+  suite "nbKarax":
     test "nbKaraxCode":
       let x = 3.14
       nbKaraxCode(x):
@@ -239,36 +267,4 @@ when moduleAvailable(karax/kbase):
           p:
             text message
       check nb.blk.code.len > 0
-      check nb.blk.context["transformedCode"].vString.len > 0
-
-    test "nbCodeDisplay":
-      nbCodeDisplay(nbJsFromCode):
-        import p5
-        echo "hi p5"
-        draw:
-          ellipse(mouseX, mouseY, 20)
-      check nb.blocks[^1].command == "nbCode"
-      check nb.blocks[^2].command == "nbJsFromCode"
-      check nb.blocks[^2].context["transformedCode"].vString.len > 0
-      check "ellipse(mouseX, mouseY, 20)" in nb.blocks[^2].context["transformedCode"].vString
-      when defined(nimibCodeFromAst):
-        check nb.blocks[^1].code.startsWith("import\n  p5")
-      else:
-        check nb.blocks[^1].code.startsWith("import p5")
-      check nb.blocks[^1].output == ""
-
-    test "nbCodeAnd":
-      nbCodeAnd(nbJsFromCode):
-        let you = "me"
-        echo "hi ", you
-      check nb.blocks[^2].command == "nbCode"
-      check nb.blocks[^1].command == "nbJsFromCode"
-      check nb.blocks[^1].context["transformedCode"].vString.len > 0
-      check "you = \"me\"" in nb.blocks[^1].context["transformedCode"].vString
-      check nb.blocks[^2].code.startsWith("let you =")
-      check nb.blocks[^2].output == "hi me\n"
-
-test "getNimibVersion()":
-  let version = getNimibVersion()
-
-  check version.count('.') == 2
+      check nb.blk.NbJsFromCode.transformedCode.len > 0
\ No newline at end of file

From 6ad1fb933bb1c1e9112374b6c924c2474fe11aa7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 Oct 2025 19:49:40 +0200
Subject: [PATCH 62/73] implement basic markdown render + fix the rest of the
 test

---
 src/nimib.nim         | 48 ++++++++++++++++++++++++++++++++++++-------
 src/nimib/globals.nim |  3 ++-
 src/nimib/renders.nim | 17 +++++++++++----
 src/nimib/themes.nim  |  2 +-
 src/nimib/types.nim   |  5 +++--
 tests/tnimib.nim      |  4 ++--
 tests/trenders.nim    | 19 +++++++++--------
 7 files changed, 72 insertions(+), 26 deletions(-)

diff --git a/src/nimib.nim b/src/nimib.nim
index adc6973..302978c 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -2,16 +2,13 @@ import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
 import std / jsonutils except toJson
 export jsonutils except toJson
 import markdown
-import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons
+import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging, renders] 
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons, renders
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
 export themes.useLatex, themes.darkMode, themes.`title=`, themes.disableHighlightJs
 
-#from nimib / renders import nil
-import nimib / renders
-
 from mustachepkg/values import searchTable, searchDirs, castStr
 export searchTable, searchDirs, castStr
 
@@ -72,7 +69,7 @@ template nbInitMd*(thisFileRel = "") =
     else:
       thisFileRel
 
-  nbInit(backend=renders.useMdBackend, theme=themes.noTheme, tfr)
+  nbInit(renderer=nbToMd, theme=themes.noTheme, tfr)
 
   if nb.options.filename == "":
     nb.doc.filename = nb.doc.filename.splitFile.name & ".md"
@@ -99,7 +96,23 @@ newNbBlock(NbCode of NbContainer):
       nb.renderPartial("nbCodeSource", jsonutils.toJson(blk))
       nbContainerToHtml(blk, nb)
       nb.renderPartial("nbCodeOutput", jsonutils.toJson(blk))
-      
+
+proc nbCodeToMd(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbCode
+  withNewlines:
+    if blk.code.len > 0:
+      withNewLines:
+        "```nim"
+        blk.code
+        "```"
+    if blk.output.len > 0:
+      withNewLines:
+        "```"
+        blk.output
+        "```"
+
+nbToMd.funcs["NbCode"] = nbCodeToMd
+
 
 template code*(nb: Nb, body: untyped) =
   let blk = newNbCode()
@@ -167,6 +180,11 @@ newNbBlock(NbText):
   toHtml:
     nb.renderPartial("nbText", jsonutils.toJson(blk))
 
+func nbTextToMd*(blk: NbBlock, nb: Nb): string =
+  blk.NbText.text
+
+nbToMd.funcs["NbText"] = nbTextToMd
+
 func text*(nb: var Nb, text: string) =
   let blk = newNbText(text=text)
   nb.add blk
@@ -183,6 +201,11 @@ newNbBlock(NbTextWithCode of NbText):
   toHtml:
     nbTextToHtml(blk, nb)
 
+func nbTextWithCodeToMd*(blk: NbBlock, nb: Nb): string =
+  blk.NbTextWithCode.text
+
+nbToMd.funcs["NbTextWithCode"] = nbTextWithCodeToMd
+
 template textWithCode*(nb: Nb, body: untyped) =
   let ttext = body
   let tcode = getCode(body)
@@ -205,6 +228,17 @@ newNbBlock(NbImage):
 </figure>
 """
 
+func nbImageToMd*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbImage
+  withNewLines:
+    &"![{blk.alt}]({blk.url})"
+    if blk.caption.len > 0:
+      withNewLines:
+        ""
+        &"**Figure:** {blk.caption}"
+
+nbToMd.funcs["NbImage"] = nbImageToMd
+
 func image*(nb: var Nb, turl: string, tcaption = "", talt = "") =
   let blk = newNbImage()
   blk.url = 
diff --git a/src/nimib/globals.nim b/src/nimib/globals.nim
index 15ee10f..3ad5e91 100644
--- a/src/nimib/globals.nim
+++ b/src/nimib/globals.nim
@@ -1,4 +1,5 @@
 import ./types
 
 var nbToJson*: Table[string, proc (s: string, i: var int): NbBlock]
-var nbToHtml* = NbRender() # since we need it for json, let's make it also for html
\ No newline at end of file
+var nbToHtml* = NbRender() # since we need it for json, let's make it also for html
+var nbToMd* = NbRender()
\ No newline at end of file
diff --git a/src/nimib/renders.nim b/src/nimib/renders.nim
index 0d505ac..0a32368 100644
--- a/src/nimib/renders.nim
+++ b/src/nimib/renders.nim
@@ -59,8 +59,9 @@ func nbTextPartial*(blk: JsonNode, nb: Nb): string =
 nbToHtml.partials["nbText"] = nbTextPartial
 
 
-proc useHtmlBackend*(doc: var NbDoc) =
-  discard
+proc useHtmlBackend*(nb: var Nb) =
+  nb.backend = nbToHtml
+
 #[   doc.partials["nbText"] = "{{&outputToHtml}}"
   doc.partials["nbCode"] = """
 {{>nbCodeSource}}
@@ -129,9 +130,17 @@ proc nbCodeToMd*(blk: NbBlock, nb: Nb): string =
 
 nbToMd.funcs["NbCode"] = nbCodeToMd ]#
 
+func nbDocToMd*(blk: NbBlock, nb: Nb): string =
+  let doc = blk.NbDoc
+  let docJson = %[] # it's unused
+  result = withNewlines:
+    nbContainerToMd(doc, nb)
+
+nbToMd.funcs["NbDoc"] = nbDocToMd
+
+proc useMdBackend*(nb: var Nb) =
+  nb.backend = nbToMd
 
-proc useMdBackend*(doc: var NbDoc) =
-  discard
 #[
   doc.partials["document"] = """
 {{#blocks}}
diff --git a/src/nimib/themes.nim b/src/nimib/themes.nim
index 1e4d148..4314912 100644
--- a/src/nimib/themes.nim
+++ b/src/nimib/themes.nim
@@ -313,5 +313,5 @@ proc `title=`*(doc: var NbDoc, text: string) =
 proc `title=`*(nb: var Nb, text: string) =
   `title=`(nb.doc, text)
 
-proc noTheme*(doc: var NbDoc) =
+proc noTheme*(doc: var Nb) =
   discard
diff --git a/src/nimib/types.nim b/src/nimib/types.nim
index 14841de..2ba4d68 100644
--- a/src/nimib/types.nim
+++ b/src/nimib/types.nim
@@ -66,7 +66,6 @@ proc blocks*(nb: var Nb): var seq[NbBlock] =
   nb.doc.blocks
 
 func render*(nb: Nb, blk: NbBlock): string =
-  debugecho "REndering block: ", blk[]
   if blk.kind in nb.backend.funcs:
     nb.backend.funcs[blk.kind](blk, nb)
   else:
@@ -85,4 +84,6 @@ func nbContainerToHtml*(blk: NbBlock, nb: Nb): string =
   let blk = blk.NbContainer
   for b in blk.blocks:
     result.add nb.render(b).strip & '\n'
-  result.strip
\ No newline at end of file
+  result.strip
+
+const nbContainerToMd* = nbContainerToHtml
diff --git a/tests/tnimib.nim b/tests/tnimib.nim
index 4825f41..e50405c 100644
--- a/tests/tnimib.nim
+++ b/tests/tnimib.nim
@@ -62,7 +62,7 @@ hi
 how are you?
 """
     when defined(nimibCodeFromAst):
-      check nb.blk.NbTextWithCode.code == "\"\"\"hi\nhow are you?\n\"\"\""
+      check nb.blk.NbTextWithCode.code == "\"\"\"\nhi\nhow are you?\n\"\"\""
     else:
       check nb.blk.NbTextWithCode.code == "\"\"\"\nhi\nhow are you?\n\"\"\""
     check nb.blk.NbTextWithCode.text == """hi
@@ -222,7 +222,7 @@ echo a
     check nb.blocks[^2].NbJsFromCode.transformedCode.len > 0
     check "ellipse(mouseX, mouseY, 20)" in nb.blocks[^2].NbJsFromCode.transformedCode
     when defined(nimibCodeFromAst):
-      check nb.blocks[^1].NbCode.code.startsWith("import\n  p5")
+      check nb.blocks[^1].NbCode.code.startsWith("import p5")
     else:
       check nb.blocks[^1].NbCode.code.startsWith("import p5")
     check nb.blocks[^1].NbCode.output == ""
diff --git a/tests/trenders.nim b/tests/trenders.nim
index 1341b20..4ee2c79 100644
--- a/tests/trenders.nim
+++ b/tests/trenders.nim
@@ -1,5 +1,4 @@
 import nimib
-import nimib / renders
 import unittest, strutils
 
 nbInit
@@ -16,7 +15,10 @@ suite "render (block), html default backend":
   test "nbCode with output":
     nbCode: echo "hi"
     check nb.render(nb.blk).strip == """
-<pre><code class="nohighlight hljs nim"><span class="hljs-keyword">echo</span> <span class="hljs-string">&quot;hi&quot;</span></code></pre><pre class="nb-output">hi</pre>"""
+<pre><code class="nohighlight hljs nim"><span class="hljs-keyword">echo</span> <span class="hljs-string">&quot;hi&quot;</span></code></pre>
+
+<pre class="nb-output">hi
+</pre>"""
 
 # switch to markdown backend
 useMdBackend nb
@@ -28,28 +30,26 @@ suite "render (block), markdown backend":
 
   test "nbCode without output":
     nbCode: discard
-    check nb.render(nb.blk) == """
-
+    check nb.render(nb.blk).strip() == """
 ```nim
 discard
 ```
-
-"""
+""".strip()
 
   test "nbCode with output":
     nbCode: echo "hi"
-    check nb.render(nb.blk) == """
+    check nb.render(nb.blk).strip() == """
 
 ```nim
 echo "hi"
 ```
 
-
 ```
 hi
+
 ```
 
-"""
+""".strip()
 
   test "nbImage with caption":
     nbImage("https://nim-lang.org/assets/img/logo_bw.png", "nim-lang.org favicon")
@@ -57,6 +57,7 @@ hi
 ![nim-lang.org favicon](https://nim-lang.org/assets/img/logo_bw.png)
 
 **Figure:** nim-lang.org favicon
+
 """
 
   test "nbImage without caption":

From a0a2638e6a12b24c1f0b708a87c92bacdefbae4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 Oct 2025 19:54:38 +0200
Subject: [PATCH 63/73] upgrade ci

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d80f86c..98fdeaf 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -17,7 +17,7 @@ jobs:
     name: Nim ${{ matrix.nim }}
     steps:
       - uses: actions/checkout@v3
-      - uses: jiro4989/setup-nim-action@v1.4.3
+      - uses: jiro4989/setup-nim-action@v2.2.2
         with:
           nim-version: ${{ matrix.nim }}
       - run: nimble -y install

From 131ae322ef2177131e72b750d0aed2e61176e347 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 Oct 2025 20:07:45 +0200
Subject: [PATCH 64/73] add pcre to tests ci

---
 .github/workflows/test.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 98fdeaf..86f0ce4 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -20,6 +20,7 @@ jobs:
       - uses: jiro4989/setup-nim-action@v2.2.2
         with:
           nim-version: ${{ matrix.nim }}
+      - run: apt install libpcre3 libpcre3-dev
       - run: nimble -y install
       - run: nimble docsdeps
       - run: nimble test

From c3be91fe310059177a0acfaeb44147aec7324060 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 Oct 2025 20:08:46 +0200
Subject: [PATCH 65/73] use sudo apt

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 86f0ce4..126fe64 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -20,7 +20,7 @@ jobs:
       - uses: jiro4989/setup-nim-action@v2.2.2
         with:
           nim-version: ${{ matrix.nim }}
-      - run: apt install libpcre3 libpcre3-dev
+      - run: sudo apt install libpcre3 libpcre3-dev
       - run: nimble -y install
       - run: nimble docsdeps
       - run: nimble test

From f0285381d1083ae4eeb27f97adb5908f197aba7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 18 Oct 2025 20:22:00 +0200
Subject: [PATCH 66/73] fix karax test

---
 tests/tnimib.nim | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/tnimib.nim b/tests/tnimib.nim
index e50405c..5d7e214 100644
--- a/tests/tnimib.nim
+++ b/tests/tnimib.nim
@@ -254,8 +254,8 @@ print(s)
 print(a)
 """
       nbPython: pyString
-      check nb.blk.code == pyString
-      check nb.blk.output == "[0, 2, 4]\n3.14\n"
+      check nb.blk.NbPython.code == pyString
+      check nb.blk.NbPython.output == "[0, 2, 4]\n3.14\n"
 
 when moduleAvailable(karax/kbase):
   suite "nbKarax":
@@ -266,5 +266,5 @@ when moduleAvailable(karax/kbase):
         karaxHtml:
           p:
             text message
-      check nb.blk.code.len > 0
-      check nb.blk.NbJsFromCode.transformedCode.len > 0
\ No newline at end of file
+      check nb.blk.NbJsFromCodeOwnFile.code.len > 0
+      check nb.blk.NbJsFromCodeOwnFile.transformedCode.len > 0
\ No newline at end of file

From b4d8577ea69032f4935e2a0110dfd5ed62562169 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 10:49:10 +0100
Subject: [PATCH 67/73] move all block definitions from nimib.nim to
 builtinBlocks.nim

---
 src/nimib.nim               | 523 +----------------------------------
 src/nimib/builtinBlocks.nim | 525 ++++++++++++++++++++++++++++++++++++
 2 files changed, 527 insertions(+), 521 deletions(-)
 create mode 100644 src/nimib/builtinBlocks.nim

diff --git a/src/nimib.nim b/src/nimib.nim
index 302978c..ec2f150 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -2,8 +2,8 @@ import std/[os, strutils, sugar, strformat, macros, macrocache, sequtils, json]
 import std / jsonutils except toJson
 export jsonutils except toJson
 import markdown
-import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging, renders] 
-export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons, renders
+import nimib / [types, blocks, docs, boost, config, options, capture, jsons, globals, jsutils, nimibSugars, sources, highlight, logging, renders, builtinBlocks] 
+export types, blocks, docs, boost, sugar, globals, nimibSugars, jsutils, sources, highlight, jsons, renders, builtinBlocks
 # types exports mustache, tables, paths
 
 from nimib / themes import nil
@@ -12,9 +12,6 @@ export themes.useLatex, themes.darkMode, themes.`title=`, themes.disableHighligh
 from mustachepkg/values import searchTable, searchDirs, castStr
 export searchTable, searchDirs, castStr
 
-template moduleAvailable*(module: untyped): bool =
-  (compiles do: import module)
-
 template nbInit*(theme: proc (nb: var Nb) = themes.useDefault, renderer: NbRender = nbToHtml, thisFileRel = "") =
   var nb {.inject.}: Nb
   nb.doc = NbDoc(kind: "NbDoc")
@@ -82,523 +79,7 @@ template newNbSlimBlock*(cmd: string, blockImpl: untyped) =
   # a slim block is a block with no body
   newNbBlock(cmd, false, nb, nb.blk, "", blockImpl) ]#
 
-# block templates
-#[ template nbCode*(body: untyped) =
-  newNbCodeBlock("nbCode", body):
-    captureStdout(nb.blk.output):
-      body ]#
-
-newNbBlock(NbCode of NbContainer):
-  code: string
-  output: string
-  toHtml:
-    withNewlines:
-      nb.renderPartial("nbCodeSource", jsonutils.toJson(blk))
-      nbContainerToHtml(blk, nb)
-      nb.renderPartial("nbCodeOutput", jsonutils.toJson(blk))
-
-proc nbCodeToMd(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbCode
-  withNewlines:
-    if blk.code.len > 0:
-      withNewLines:
-        "```nim"
-        blk.code
-        "```"
-    if blk.output.len > 0:
-      withNewLines:
-        "```"
-        blk.output
-        "```"
-
-nbToMd.funcs["NbCode"] = nbCodeToMd
-
-
-template code*(nb: Nb, body: untyped) =
-  let blk = newNbCode()
-  blk.code = getCode(body)
-  nb.withContainer(blk):
-    captureStdout(blk.output):
-      body
-  nb.add blk
-
-template nbCode*(body: untyped) =
-  nb.code:
-    body
-
-template codeSkip*(nb: Nb, body: untyped) =
-  let blk = newNbCode()
-  blk.code = getCode(body)
-  nb.add blk
-
-template nbCodeSkip*(body: untyped) =
-  nb.codeSkip(body)
-
-#[ template nbCodeSkip*(body: untyped) =
-  newNbCodeBlock("nbCodeSkip", body):
-    discard ]#
-
-template capture*(nb: Nb, body: untyped) =
-  let blk = newNbCode()
-  nb.withContainer(blk):
-    captureStdout(blk.output):
-      body
-  nb.add blk
-
-template nbCapture*(body: untyped) =
-  nb.capture(body)
-
-#[ template nbCapture*(body: untyped) =
-  newNbCodeBlock("nbCapture", body):
-    captureStdout(nb.blk.output):
-      body ]#
-
-template codeInBlock*(nb: Nb, body: untyped) =
-  block:
-    nb.code:
-      body
-
-template nbCodeInBlock*(body: untyped): untyped =
-  nb.codeInBlock:
-    body
-
-template nimibCode*(body: untyped) =
-  nbCode:
-    body
-
-#[ template nimibCode*(body: untyped) =
-  newNbCodeBlock("nimibCode", body):
-    discard
-  body ]#
-
-#[ template nbText*(text: string) =
-  newNbSlimBlock("nbText"):
-    nb.blk.output = text ]#
-
-newNbBlock(NbText):
-  text: string
-  toHtml:
-    nb.renderPartial("nbText", jsonutils.toJson(blk))
-
-func nbTextToMd*(blk: NbBlock, nb: Nb): string =
-  blk.NbText.text
-
-nbToMd.funcs["NbText"] = nbTextToMd
-
-func text*(nb: var Nb, text: string) =
-  let blk = newNbText(text=text)
-  nb.add blk
-
-template nbText*(ttext: string) =
-  nb.text(ttext)
-
-#[ template nbTextWithCode*(body: untyped) =
-  newNbCodeBlock("nbText", body):
-    nb.blk.output = body ]#
-
-newNbBlock(NbTextWithCode of NbText):
-  code: string
-  toHtml:
-    nbTextToHtml(blk, nb)
-
-func nbTextWithCodeToMd*(blk: NbBlock, nb: Nb): string =
-  blk.NbTextWithCode.text
-
-nbToMd.funcs["NbTextWithCode"] = nbTextWithCodeToMd
-
-template textWithCode*(nb: Nb, body: untyped) =
-  let ttext = body
-  let tcode = getCode(body)
-  let blk = newNbTextWithCode(text=ttext, code=tcode)
-  nb.add blk
-
-template nbTextWithCode*(body: untyped) =
-  nb.textWithCode:
-    body
-
-newNbBlock(NbImage):
-  url: string
-  caption: string
-  alt: string
-  toHtml:
-    &"""
-<figure>
-  <img src="{blk.url}" alt="{blk.alt}">
-  <figcaption>{blk.caption}</figcaption>
-</figure>
-"""
-
-func nbImageToMd*(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbImage
-  withNewLines:
-    &"![{blk.alt}]({blk.url})"
-    if blk.caption.len > 0:
-      withNewLines:
-        ""
-        &"**Figure:** {blk.caption}"
-
-nbToMd.funcs["NbImage"] = nbImageToMd
-
-func image*(nb: var Nb, turl: string, tcaption = "", talt = "") =
-  let blk = newNbImage()
-  blk.url = 
-    if isAbsolute(turl) or turl.startsWith("http"):
-      turl
-    else:
-      nb.doc.context{"path_to_root"}.getStr / turl
-  blk.alt = if talt.len == 0: tcaption else: talt
-  blk.caption = tcaption
-  nb.add blk
-
-template nbImage*(url: string, caption = "", alt = "") =
-  nb.image(url, caption, alt)
-
-#[ template nbImage*(url: string, caption = "", alt = "") =
-  newNbSlimBlock("nbImage"):
-    nb.blk.context["url"] = nb.relToRoot(url) 
-    nb.blk.context["alt_text"] = 
-      if alt == "":
-        caption
-      else:
-        alt
-        
-    nb.blk.context["caption"] = caption ]#
-
-newNbBlock(NbFile):
-  filename: string
-  ext: string
-  content: string
-  toHtml:
-    &"""
-<pre>{blk.filename}</pre>
-<pre><code class="{blk.ext} hljs">{blk.content}</code></pre>
-"""
-# Make pre-code with hljs-extensions into a partial! Or a function that calls a partial even? (that constructs the JsNode for us)
-
-proc file*(nb: var Nb, tname: string, tcontent: string) =
-  ## Generic string file
-  tname.writeFile tcontent
-  let blk = newNbFile(filename=tname, ext=tname.getExt, content=tcontent)
-  nb.add blk
-
-template file*(nb: Nb, tname: string, body: untyped) =
-  ## Read code and write it to file
-  let content = getCode(body)
-  tname.writeFile content
-  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
-  nb.add blk
-
-proc file*(nb: var Nb, tname: string) =
-  ## Read content from a file instead of writing to it
-  let content = readFile(tname)
-  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
-  nb.add blk
-
-newNbBlock(NbVideo):
-  url: string
-  filetype: string
-  autoplay: bool
-  muted: bool
-  loop: bool
-  toHtml:
-    withNewLines:
-      "<video controls"
-      if blk.loop: "loop"
-      if blk.autoplay: "autoplay"
-      if blk.muted: "muted"
-      ">"
-      &"""<source src="{blk.url}" """
-      if blk.filetype.len > 0:
-        &"""type="{blk.filetype}" """
-      ">"
-      "Your browser does not support the video element.</video>"
-
-func video*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
-  let blk = newNbVideo(autoplay=autoplay, muted=muted, loop=loop)
-  blk.url = nb.doc.relToRoot(url)
-  blk.filetype = 
-    if filetype == "": "video/" & url.splitFile.ext[1..^1] # remove the leading dot
-    else: filetype
-  nb.add blk
-  
-# todo captions and subtitles support maybe?
-template nbVideo*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
-  nb.video(url, filetype, autoplay, muted, loop)
-
-newNbBlock(NbAudio of NbVideo):
-  toHtml: 
-    withNewLines:
-      "<audio controls"
-      if blk.loop: "loop"
-      if blk.autoplay: "autoplay"
-      if blk.muted: "muted"
-      ">"
-      &"""<source src="{blk.url}" """
-      if blk.filetype.len > 0:
-        &"""type="{blk.filetype}" """
-      ">"
-      "Your browser does not support the video element.</audio>"
-
-func audio*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
-  let blk = newNbAudio(autoplay=autoplay, muted=muted, loop=loop)
-  blk.url = nb.doc.relToRoot(url)
-  blk.filetype = 
-    if filetype == "": "audio/" & url.splitFile.ext[1..^1] # remove the leading dot
-    else: filetype
-  nb.add blk
-
-template nbAudio*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
-  nb.audio(url, filetype, autoplay, muted, loop)
-
-template nbFile*(name: string, content: string) =
-  nb.file(name, content)
-
-template nbFile*(name: string, body: untyped) =
-  nb.file(name, body)
-
-template nbFile*(name: string) =
-  nb.file(name)
-
-#[ template nbFile*(name: string, content: string) =
-  ## Generic string file
-  newNbSlimBlock("nbFile"):
-    name.writeFile content
-    nb.blk.context["filename"] = name
-    nb.blk.context["ext"] = name.getExt
-    nb.blk.context["content"] = content
-
-template nbFile*(name: string, body: untyped) =
-  newNbCodeBlock("nbFile", body):
-    name.writeFile nb.blk.code
-    nb.blk.context["filename"] = name
-    nb.blk.context["ext"] = name.getExt
-    nb.blk.context["content"] = nb.blk.code
-
-template nbFile*(name: string) =
-  ## Read content from a file instead of writing to it
-  newNbSlimBlock("nbFile"):
-    nb.blk.context["filename"] = name
-    nb.blk.context["ext"] = name.getExt
-    nb.blk.context["content"] = readFile(name) ]#
-
-when moduleAvailable(nimpy):
-  newNbBlock(NbPython of NbCode):
-    toHtml:
-      withNewlines:
-        if blk.code.len > 0:
-          &"<pre><code class=\"hljs python\">{blk.code}</code></pre>"
-        if blk.output.len > 0:
-          &"<pre class=\"nb-output\">{blk.output}</pre>"
-
-  template nbInitPython*() =
-    import nimpy
-    let nbPythonBuiltins = pyBuiltinsModule()
-
-    proc python(nb: var Nb, pythonStr: string) =
-      let blk = newNbPython(code = pythonStr)
-      captureStdout(blk.output):
-          discard nbPythonBuiltins.exec(pythonStr)
-      nb.add blk
-    
-    template nbPython(pythonStr: string) =
-      nb.python(pythonStr)
-
-    #[ template nbPython(pythonStr: string) =
-      newNbSlimBlock("nbPython"):
-        nb.blk.code = pythonStr
-        captureStdout(nb.blk.output):
-          discard nbPythonBuiltins.exec(pythonStr) ]#
-
-newNbBlock(NbRawHtml):
-  html: string
-  toHtml:
-    blk.html
-
-func rawHtml*(nb: var Nb, content: string) =
-  let blk = newNbRawHtml(html = content)
-  nb.add blk
-
-template nbRawHtml*(content: string) =
-  nb.rawHtml(content)
-
-func show*[T](nb: var Nb, obj: T) =
-  nb.rawHtml(obj.toHtml())
-
-template nbShow*(obj: untyped) =
-  nb.show(obj)
-
-newNbBlock(NbDiv of NbContainer):
-  class: string
-  style: string
-  toHtml:
-    withNewLines:
-      &"<div class=\"{blk.class}\" style=\"{blk.style}\">"
-      nbContainerToHtml(blk, nb)
-      "</div>"
-
-template nbDiv*(classes: string, styles: string, body: untyped) =
-  let blk = newNbDiv(class=classes, style=styles)
-  nb.withContainer(blk):
-    body
-  nb.add blk
-
-template nbDiv*(body: untyped) =
-  nbDiv("", ""):
-    body
-
-#[ template nbShow*(obj: untyped) =
-  nbRawHtml(obj.toHtml())
-
-template nbRawOutput*(content: string) {.deprecated: "Use nbRawHtml instead".} = 
-  nbRawHtml(content)
-
-template nbRawHtml*(content: string) =
-  newNbSlimBlock("nbRawHtml"):
-    nb.blk.output = content ]#
-
-func nbJsFromStringInit*(body: string): NbBlock =
-  newNbJsFromCode(code=body, transformedCode=body, putAtTop=false)
-
-#[ template nbJsFromStringInit*(body: string): NbBlock =
-  var result = NbBlock(command: "nbJsFromCode", code: body, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
-  result.context["transformedCode"] = body
-  result.context["putAtTop"] = false
-  result ]#
-
-func addStringToJs*(script: NbJsFromCode or NbJsFromCodeOwnFile, body: string) =
-  script.code &= "\n" & body
-  script.transformedCode &= "\n" & body
-
-#[ template addStringToJs*(script: NbBlock, body: string) =
-  script.code &= "\n" & body
-  script.context["transformedCode"] = script.context["transformedCode"].vString & "\n" & body ]#
-
-#[ func addToDocAsJs*(nb: var Nb, script: NbBlock) =
-  nb.add script
-
-template addToDocAsJs*(script: NbBlock) =
-  nb.blocks.add script
-  nb.blk = script ]#
-
-func jsFromString*(nb: var Nb, body: string) =
-  let script = nbJsFromStringInit(body)
-  nb.add script
-
-template nbJsFromString*(body: string) =
-  nb.jsFromString(body)
-
-template jsFromCode*(nb: var Nb, args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
-  nb.add blk
-
-template nbJsFromCode*(args: varargs[untyped]) =
-  nb.jsFromCode(args)
-
-template jsFromCodeInBlock*(nb: var Nb, args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=true, args)
-  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
-  nb.add blk
-
-template nbJsFromCodeInBlock*(args: varargs[untyped]) =
-  nb.jsFromCodeInBlock(args)
-
-template jsFromCodeGlobal*(nb: var Nb, args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=true)
-  nb.add blk
-
-template nbJsFromCodeGlobal*(args: varargs[untyped]) =
-  nb.jsFromCodeGlobal(args)
-
-template jsFromCodeOwnFile*(nb: var Nb, args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = newNbJsFromCodeOwnFile(code=originalCode, transformedCode=code)
-  nb.add blk
-
-template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
-  nb.jsFromCodeOwnFile(args)
-
-#[ template nbJsFromCode*(args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
-  result.context["transformedCode"] = code
-  result.context["putAtTop"] = false
-  result.addToDocAsJs
-
-template nbJsFromCodeInBlock*(args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=true, args)
-  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
-  result.context["transformedCode"] = code
-  result.context["putAtTop"] = false
-  result.addToDocAsJs
-
-template nbJsFromCodeGlobal*(args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
-  result.context["transformedCode"] = code
-  result.context["putAtTop"] = true
-  result.addToDocAsJs
-
-template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
-  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  var result = NbBlock(command: "nbJsFromCodeOwnFile", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
-  result.context["transformedCode"] = code
-  result.addToDocAsJs
-
-template nbCodeToJs*(args: varargs[untyped]) {.deprecated: "Use nbJsFromCode or nbJsFromString instead".} =
-  nbJsFromCode(args) ]#
-
-
-when moduleAvailable(karax/kbase):
-  template karaxCode*(nb: var Nb, args: varargs[untyped]) =
-    let rootId = "karax-" & $nb.doc.newId()
-    nb.rawHtml: "<div id=\"" & rootId & "\"></div>"
-    nbKaraxCodeBackend(rootId, args)
-
-  template nbKaraxCode*(args: varargs[untyped]) =
-    nb.karaxCode(args)
-
-when moduleAvailable(happyx):
-  template happyxCode*(nb: var Nb, args: varargs[untyped]) =
-    let rootId = "happyx-" & $nb.doc.newId()
-    nbRawHtml: "<div id=\"" & rootId & "\"></div>"
-    nbHappyxCodeBackend(rootId, args)
-
-  template nbHappyxCode*(args: varargs[untyped]) =
-    nb.happyxCode(args)
-
-#[ template nbJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
-  nb.blk.context["js_show_nim_source"] = true
-  if message.len > 0:
-    nb.blk.context["js_show_nim_source_message"] = message
-
-template nbCodeToJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
-  nbJsShowSource(message) ]#
-
-template codeDisplay*(nb: var Nb, tmplCall: untyped, body: untyped) =
-  tmplCall:
-    body
-  nb.codeSkip:
-    body
-
-template nbCodeDisplay*(tmplCall: untyped, body: untyped) =
-  ## display codes used in a template (e.g. nbJsFromCode) after the template call
-  nb.codeDisplay(tmplCall, body)
-
-template codeAnd*(nb: var Nb, tmplCall: untyped, body: untyped) =
-  ## can be used to run code both in c and js backends (e.g. nbCodeAnd(nbJsFromCode))
-  nb.code: # this should work because template name starts with nbCode
-    body
-  tmplCall:
-    body
-
-template nbCodeAnd*(tmplCall: untyped, body: untyped) =
-  nb.codeAnd(tmplCall, body)
 
-template nbClearOutput*() =
-  if not nb.blk.isNil and nb.blk of NbCode:
-    nb.blk.NbCode.output = ""
 
 template nbSave* =
   # order if searchDirs/searchTable is relevant: directories have higher priority. rationale:
diff --git a/src/nimib/builtinBlocks.nim b/src/nimib/builtinBlocks.nim
new file mode 100644
index 0000000..1f2e1fd
--- /dev/null
+++ b/src/nimib/builtinBlocks.nim
@@ -0,0 +1,525 @@
+import std / [strformat, os, strutils, json]
+import std / jsonutils except toJson
+
+import ./types, ./blocks, ./capture, ./nimibSugars, ./globals, ./jsons, ./paths, ./docs, ./jsutils
+
+template moduleAvailable*(module: untyped): bool =
+  (compiles do: import module)
+
+# block templates
+#[ template nbCode*(body: untyped) =
+  newNbCodeBlock("nbCode", body):
+    captureStdout(nb.blk.output):
+      body ]#
+
+newNbBlock(NbCode of NbContainer):
+  code: string
+  output: string
+  toHtml:
+    withNewlines:
+      nb.renderPartial("nbCodeSource", jsonutils.toJson(blk))
+      nbContainerToHtml(blk, nb)
+      nb.renderPartial("nbCodeOutput", jsonutils.toJson(blk))
+
+proc nbCodeToMd(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbCode
+  withNewlines:
+    if blk.code.len > 0:
+      withNewLines:
+        "```nim"
+        blk.code
+        "```"
+    if blk.output.len > 0:
+      withNewLines:
+        "```"
+        blk.output
+        "```"
+
+nbToMd.funcs["NbCode"] = nbCodeToMd
+
+
+template code*(nb: Nb, body: untyped) =
+  let blk = newNbCode()
+  blk.code = getCode(body)
+  nb.withContainer(blk):
+    captureStdout(blk.output):
+      body
+  nb.add blk
+
+template nbCode*(body: untyped) =
+  nb.code:
+    body
+
+template codeSkip*(nb: Nb, body: untyped) =
+  let blk = newNbCode()
+  blk.code = getCode(body)
+  nb.add blk
+
+template nbCodeSkip*(body: untyped) =
+  nb.codeSkip(body)
+
+#[ template nbCodeSkip*(body: untyped) =
+  newNbCodeBlock("nbCodeSkip", body):
+    discard ]#
+
+template capture*(nb: Nb, body: untyped) =
+  let blk = newNbCode()
+  nb.withContainer(blk):
+    captureStdout(blk.output):
+      body
+  nb.add blk
+
+template nbCapture*(body: untyped) =
+  nb.capture(body)
+
+#[ template nbCapture*(body: untyped) =
+  newNbCodeBlock("nbCapture", body):
+    captureStdout(nb.blk.output):
+      body ]#
+
+template codeInBlock*(nb: Nb, body: untyped) =
+  block:
+    nb.code:
+      body
+
+template nbCodeInBlock*(body: untyped): untyped =
+  nb.codeInBlock:
+    body
+
+template nimibCode*(body: untyped) =
+  nbCode:
+    body
+
+#[ template nimibCode*(body: untyped) =
+  newNbCodeBlock("nimibCode", body):
+    discard
+  body ]#
+
+#[ template nbText*(text: string) =
+  newNbSlimBlock("nbText"):
+    nb.blk.output = text ]#
+
+newNbBlock(NbText):
+  text: string
+  toHtml:
+    nb.renderPartial("nbText", jsonutils.toJson(blk))
+
+func nbTextToMd*(blk: NbBlock, nb: Nb): string =
+  blk.NbText.text
+
+nbToMd.funcs["NbText"] = nbTextToMd
+
+func text*(nb: var Nb, text: string) =
+  let blk = newNbText(text=text)
+  nb.add blk
+
+template nbText*(ttext: string) =
+  nb.text(ttext)
+
+#[ template nbTextWithCode*(body: untyped) =
+  newNbCodeBlock("nbText", body):
+    nb.blk.output = body ]#
+
+newNbBlock(NbTextWithCode of NbText):
+  code: string
+  toHtml:
+    nbTextToHtml(blk, nb)
+
+func nbTextWithCodeToMd*(blk: NbBlock, nb: Nb): string =
+  blk.NbTextWithCode.text
+
+nbToMd.funcs["NbTextWithCode"] = nbTextWithCodeToMd
+
+template textWithCode*(nb: Nb, body: untyped) =
+  let ttext = body
+  let tcode = getCode(body)
+  let blk = newNbTextWithCode(text=ttext, code=tcode)
+  nb.add blk
+
+template nbTextWithCode*(body: untyped) =
+  nb.textWithCode:
+    body
+
+newNbBlock(NbImage):
+  url: string
+  caption: string
+  alt: string
+  toHtml:
+    &"""
+<figure>
+  <img src="{blk.url}" alt="{blk.alt}">
+  <figcaption>{blk.caption}</figcaption>
+</figure>
+"""
+
+func nbImageToMd*(blk: NbBlock, nb: Nb): string =
+  let blk = blk.NbImage
+  withNewLines:
+    &"![{blk.alt}]({blk.url})"
+    if blk.caption.len > 0:
+      withNewLines:
+        ""
+        &"**Figure:** {blk.caption}"
+
+nbToMd.funcs["NbImage"] = nbImageToMd
+
+func image*(nb: var Nb, turl: string, tcaption = "", talt = "") =
+  let blk = newNbImage()
+  blk.url = 
+    if isAbsolute(turl) or turl.startsWith("http"):
+      turl
+    else:
+      nb.doc.context{"path_to_root"}.getStr / turl
+  blk.alt = if talt.len == 0: tcaption else: talt
+  blk.caption = tcaption
+  nb.add blk
+
+template nbImage*(url: string, caption = "", alt = "") =
+  nb.image(url, caption, alt)
+
+#[ template nbImage*(url: string, caption = "", alt = "") =
+  newNbSlimBlock("nbImage"):
+    nb.blk.context["url"] = nb.relToRoot(url) 
+    nb.blk.context["alt_text"] = 
+      if alt == "":
+        caption
+      else:
+        alt
+        
+    nb.blk.context["caption"] = caption ]#
+
+newNbBlock(NbFile):
+  filename: string
+  ext: string
+  content: string
+  toHtml:
+    &"""
+<pre>{blk.filename}</pre>
+<pre><code class="{blk.ext} hljs">{blk.content}</code></pre>
+"""
+# Make pre-code with hljs-extensions into a partial! Or a function that calls a partial even? (that constructs the JsNode for us)
+
+proc file*(nb: var Nb, tname: string, tcontent: string) =
+  ## Generic string file
+  tname.writeFile tcontent
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=tcontent)
+  nb.add blk
+
+template file*(nb: Nb, tname: string, body: untyped) =
+  ## Read code and write it to file
+  let content = getCode(body)
+  tname.writeFile content
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
+  nb.add blk
+
+proc file*(nb: var Nb, tname: string) =
+  ## Read content from a file instead of writing to it
+  let content = readFile(tname)
+  let blk = newNbFile(filename=tname, ext=tname.getExt, content=content)
+  nb.add blk
+
+newNbBlock(NbVideo):
+  url: string
+  filetype: string
+  autoplay: bool
+  muted: bool
+  loop: bool
+  toHtml:
+    withNewLines:
+      "<video controls"
+      if blk.loop: "loop"
+      if blk.autoplay: "autoplay"
+      if blk.muted: "muted"
+      ">"
+      &"""<source src="{blk.url}" """
+      if blk.filetype.len > 0:
+        &"""type="{blk.filetype}" """
+      ">"
+      "Your browser does not support the video element.</video>"
+
+func video*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  let blk = newNbVideo(autoplay=autoplay, muted=muted, loop=loop)
+  blk.url = nb.doc.relToRoot(url)
+  blk.filetype = 
+    if filetype == "": "video/" & url.splitFile.ext[1..^1] # remove the leading dot
+    else: filetype
+  nb.add blk
+  
+# todo captions and subtitles support maybe?
+template nbVideo*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  nb.video(url, filetype, autoplay, muted, loop)
+
+newNbBlock(NbAudio of NbVideo):
+  toHtml: 
+    withNewLines:
+      "<audio controls"
+      if blk.loop: "loop"
+      if blk.autoplay: "autoplay"
+      if blk.muted: "muted"
+      ">"
+      &"""<source src="{blk.url}" """
+      if blk.filetype.len > 0:
+        &"""type="{blk.filetype}" """
+      ">"
+      "Your browser does not support the video element.</audio>"
+
+func audio*(nb: var Nb, url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  let blk = newNbAudio(autoplay=autoplay, muted=muted, loop=loop)
+  blk.url = nb.doc.relToRoot(url)
+  blk.filetype = 
+    if filetype == "": "audio/" & url.splitFile.ext[1..^1] # remove the leading dot
+    else: filetype
+  nb.add blk
+
+template nbAudio*(url: string, filetype: string = "", autoplay = false, muted = false, loop: bool = false) =
+  nb.audio(url, filetype, autoplay, muted, loop)
+
+template nbFile*(name: string, content: string) =
+  nb.file(name, content)
+
+template nbFile*(name: string, body: untyped) =
+  nb.file(name, body)
+
+template nbFile*(name: string) =
+  nb.file(name)
+
+#[ template nbFile*(name: string, content: string) =
+  ## Generic string file
+  newNbSlimBlock("nbFile"):
+    name.writeFile content
+    nb.blk.context["filename"] = name
+    nb.blk.context["ext"] = name.getExt
+    nb.blk.context["content"] = content
+
+template nbFile*(name: string, body: untyped) =
+  newNbCodeBlock("nbFile", body):
+    name.writeFile nb.blk.code
+    nb.blk.context["filename"] = name
+    nb.blk.context["ext"] = name.getExt
+    nb.blk.context["content"] = nb.blk.code
+
+template nbFile*(name: string) =
+  ## Read content from a file instead of writing to it
+  newNbSlimBlock("nbFile"):
+    nb.blk.context["filename"] = name
+    nb.blk.context["ext"] = name.getExt
+    nb.blk.context["content"] = readFile(name) ]#
+
+when moduleAvailable(nimpy):
+  newNbBlock(NbPython of NbCode):
+    toHtml:
+      withNewlines:
+        if blk.code.len > 0:
+          &"<pre><code class=\"hljs python\">{blk.code}</code></pre>"
+        if blk.output.len > 0:
+          &"<pre class=\"nb-output\">{blk.output}</pre>"
+
+  template nbInitPython*() =
+    import nimpy
+    let nbPythonBuiltins = pyBuiltinsModule()
+
+    proc python(nb: var Nb, pythonStr: string) =
+      let blk = newNbPython(code = pythonStr)
+      captureStdout(blk.output):
+          discard nbPythonBuiltins.exec(pythonStr)
+      nb.add blk
+    
+    template nbPython(pythonStr: string) =
+      nb.python(pythonStr)
+
+    #[ template nbPython(pythonStr: string) =
+      newNbSlimBlock("nbPython"):
+        nb.blk.code = pythonStr
+        captureStdout(nb.blk.output):
+          discard nbPythonBuiltins.exec(pythonStr) ]#
+
+newNbBlock(NbRawHtml):
+  html: string
+  toHtml:
+    blk.html
+
+func rawHtml*(nb: var Nb, content: string) =
+  let blk = newNbRawHtml(html = content)
+  nb.add blk
+
+template nbRawHtml*(content: string) =
+  nb.rawHtml(content)
+
+func show*[T](nb: var Nb, obj: T) =
+  nb.rawHtml(obj.toHtml())
+
+template nbShow*(obj: untyped) =
+  nb.show(obj)
+
+newNbBlock(NbDiv of NbContainer):
+  class: string
+  style: string
+  toHtml:
+    withNewLines:
+      &"<div class=\"{blk.class}\" style=\"{blk.style}\">"
+      nbContainerToHtml(blk, nb)
+      "</div>"
+
+template nbDiv*(classes: string, styles: string, body: untyped) =
+  let blk = newNbDiv(class=classes, style=styles)
+  nb.withContainer(blk):
+    body
+  nb.add blk
+
+template nbDiv*(body: untyped) =
+  nbDiv("", ""):
+    body
+
+#[ template nbShow*(obj: untyped) =
+  nbRawHtml(obj.toHtml())
+
+template nbRawOutput*(content: string) {.deprecated: "Use nbRawHtml instead".} = 
+  nbRawHtml(content)
+
+template nbRawHtml*(content: string) =
+  newNbSlimBlock("nbRawHtml"):
+    nb.blk.output = content ]#
+
+func nbJsFromStringInit*(body: string): NbBlock =
+  newNbJsFromCode(code=body, transformedCode=body, putAtTop=false)
+
+#[ template nbJsFromStringInit*(body: string): NbBlock =
+  var result = NbBlock(command: "nbJsFromCode", code: body, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
+  result.context["transformedCode"] = body
+  result.context["putAtTop"] = false
+  result ]#
+
+func addStringToJs*(script: NbJsFromCode or NbJsFromCodeOwnFile, body: string) =
+  script.code &= "\n" & body
+  script.transformedCode &= "\n" & body
+
+#[ template addStringToJs*(script: NbBlock, body: string) =
+  script.code &= "\n" & body
+  script.context["transformedCode"] = script.context["transformedCode"].vString & "\n" & body ]#
+
+#[ func addToDocAsJs*(nb: var Nb, script: NbBlock) =
+  nb.add script
+
+template addToDocAsJs*(script: NbBlock) =
+  nb.blocks.add script
+  nb.blk = script ]#
+
+func jsFromString*(nb: var Nb, body: string) =
+  let script = nbJsFromStringInit(body)
+  nb.add script
+
+template nbJsFromString*(body: string) =
+  nb.jsFromString(body)
+
+template jsFromCode*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
+  nb.add blk
+
+template nbJsFromCode*(args: varargs[untyped]) =
+  nb.jsFromCode(args)
+
+template jsFromCodeInBlock*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=true, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=false)
+  nb.add blk
+
+template nbJsFromCodeInBlock*(args: varargs[untyped]) =
+  nb.jsFromCodeInBlock(args)
+
+template jsFromCodeGlobal*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCode(code=originalCode, transformedCode=code, putAtTop=true)
+  nb.add blk
+
+template nbJsFromCodeGlobal*(args: varargs[untyped]) =
+  nb.jsFromCodeGlobal(args)
+
+template jsFromCodeOwnFile*(nb: var Nb, args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  let blk = newNbJsFromCodeOwnFile(code=originalCode, transformedCode=code)
+  nb.add blk
+
+template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
+  nb.jsFromCodeOwnFile(args)
+
+#[ template nbJsFromCode*(args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
+  result.context["transformedCode"] = code
+  result.context["putAtTop"] = false
+  result.addToDocAsJs
+
+template nbJsFromCodeInBlock*(args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=true, args)
+  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
+  result.context["transformedCode"] = code
+  result.context["putAtTop"] = false
+  result.addToDocAsJs
+
+template nbJsFromCodeGlobal*(args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  var result = NbBlock(command: "nbJsFromCode", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
+  result.context["transformedCode"] = code
+  result.context["putAtTop"] = true
+  result.addToDocAsJs
+
+template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
+  let (code, originalCode) = nimToJsString(putCodeInBlock=false, args)
+  var result = NbBlock(command: "nbJsFromCodeOwnFile", code: originalCode, context: newContext(searchDirs = @[], partials = nb.partials), output: "")
+  result.context["transformedCode"] = code
+  result.addToDocAsJs
+
+template nbCodeToJs*(args: varargs[untyped]) {.deprecated: "Use nbJsFromCode or nbJsFromString instead".} =
+  nbJsFromCode(args) ]#
+
+
+when moduleAvailable(karax/kbase):
+  template karaxCode*(nb: var Nb, args: varargs[untyped]) =
+    let rootId = "karax-" & $nb.doc.newId()
+    nb.rawHtml: "<div id=\"" & rootId & "\"></div>"
+    nbKaraxCodeBackend(rootId, args)
+
+  template nbKaraxCode*(args: varargs[untyped]) =
+    nb.karaxCode(args)
+
+when moduleAvailable(happyx):
+  template happyxCode*(nb: var Nb, args: varargs[untyped]) =
+    let rootId = "happyx-" & $nb.doc.newId()
+    nbRawHtml: "<div id=\"" & rootId & "\"></div>"
+    nbHappyxCodeBackend(rootId, args)
+
+  template nbHappyxCode*(args: varargs[untyped]) =
+    nb.happyxCode(args)
+
+#[ template nbJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
+  nb.blk.context["js_show_nim_source"] = true
+  if message.len > 0:
+    nb.blk.context["js_show_nim_source_message"] = message
+
+template nbCodeToJsShowSource*(message: string = "") {.deprecated: "Use nbCodeDisplay instead".} =
+  nbJsShowSource(message) ]#
+
+template codeDisplay*(nb: var Nb, tmplCall: untyped, body: untyped) =
+  tmplCall:
+    body
+  nb.codeSkip:
+    body
+
+template nbCodeDisplay*(tmplCall: untyped, body: untyped) =
+  ## display codes used in a template (e.g. nbJsFromCode) after the template call
+  nb.codeDisplay(tmplCall, body)
+
+template codeAnd*(nb: var Nb, tmplCall: untyped, body: untyped) =
+  ## can be used to run code both in c and js backends (e.g. nbCodeAnd(nbJsFromCode))
+  nb.code: # this should work because template name starts with nbCode
+    body
+  tmplCall:
+    body
+
+template nbCodeAnd*(tmplCall: untyped, body: untyped) =
+  nb.codeAnd(tmplCall, body)
+
+template nbClearOutput*() =
+  if not nb.blk.isNil and nb.blk of NbCode:
+    nb.blk.NbCode.output = ""
\ No newline at end of file

From 2fd2bedf5693598d8d9d902486d0e66da86eb004 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 10:51:41 +0100
Subject: [PATCH 68/73] remove Nim 1.6 from tests

---
 .github/workflows/test.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 126fe64..b366376 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -10,7 +10,6 @@ jobs:
     strategy:
       matrix:
         nim:
-          - '1.6.x'
           - 'stable'
           - 'devel'
       fail-fast: false

From 30ed2022d63015206c4613dc6ba7dc58dae7f42b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 11:00:12 +0100
Subject: [PATCH 69/73] remove sandbox

---
 sandbox/hugoop/one.nim    |  32 ---
 sandbox/hugoop/three.nim  |  51 ----
 sandbox/hugoop/two.nim    |  51 ----
 sandbox/minib/capture.nim |  30 --
 sandbox/minib/jsutils.nim | 228 ---------------
 sandbox/minib/minib.nim   | 579 --------------------------------------
 sandbox/nim.cfg           |   2 -
 sandbox/notes.md          | 230 ---------------
 8 files changed, 1203 deletions(-)
 delete mode 100644 sandbox/hugoop/one.nim
 delete mode 100644 sandbox/hugoop/three.nim
 delete mode 100644 sandbox/hugoop/two.nim
 delete mode 100644 sandbox/minib/capture.nim
 delete mode 100644 sandbox/minib/jsutils.nim
 delete mode 100644 sandbox/minib/minib.nim
 delete mode 100644 sandbox/nim.cfg
 delete mode 100644 sandbox/notes.md

diff --git a/sandbox/hugoop/one.nim b/sandbox/hugoop/one.nim
deleted file mode 100644
index 2cac4ba..0000000
--- a/sandbox/hugoop/one.nim
+++ /dev/null
@@ -1,32 +0,0 @@
-import jsony
-
-type
-  Nimib = ref object of RootObj
-    a, b, c: int
-  NimibChild = ref object of Nimib
-    d, e: float
-
-
-method dump(n: Nimib): string =
-  n[].toJson()
-
-when not defined(noNimibChild): # essential, see below
-  method dump(n: NimibChild): string =
-    n[].toJson()
-
-proc dumpHook*(s: var string, v: Nimib) =
-  s.add v.dump()
-
-let n1: Nimib = Nimib(a: 1, b: 2, c: 3)
-let n2: Nimib = NimibChild(d: 3.14, e: 4.56)
-
-echo n1.toJson()
-echo n2.toJson()
-#[ nim r one
-{"a":1,"b":2,"c":3}
-{"d":3.14,"e":4.56,"a":0,"b":0,"c":0}
-]#
-#[ nim -d:noNimibChild r one
-{"a":1,"b":2,"c":3}
-{"a":0,"b":0,"c":0}
-]#
\ No newline at end of file
diff --git a/sandbox/hugoop/three.nim b/sandbox/hugoop/three.nim
deleted file mode 100644
index 003fb55..0000000
--- a/sandbox/hugoop/three.nim
+++ /dev/null
@@ -1,51 +0,0 @@
-import jsony, tables
-
-type
-  Nimib = ref object of RootObj
-    a, b, c: int
-    typename: string
-  NimibChild = ref object of Nimib
-    d, e: float
-
-var parseDefs: Table[string, proc (s: string, i: var int): Nimib]
-
-template registerBlock(typename: untyped) =
-  parseDefs[$typename] =
-    proc (s: string, i: var int): Nimib =
-      var v: typename
-      new v
-      parseHook(s, i, v[])
-      result = v
-
-  method dump(n: typename): string =
-    n[].toJson()
-
-proc parseHook*(s: string, i: var int, v: var Nimib) =
-  # First parse the typename
-  var n: Nimib = Nimib()
-  let current_i = i
-  parseHook(s, i, n[])
-  # Reset i
-  i = current_i
-  # Parse the correct type
-  let typename = n.typename
-  v = parseDefs[typename](s, i)
-
-registerBlock(Nimib)
-registerBlock(NimibChild)
-
-# moved this here, I do not need to add dummy dumphook
-proc dumpHook*(s: var string, v: Nimib) =
-  s.add v.dump()
-
-
-let n1: Nimib = Nimib(a: 1, b: 2, c: 3, typename: "Nimib")
-let n2: Nimib = NimibChild(a: 100, d: 3.14, e: 4.56, typename: "NimibChild")
-
-echo n1.toJson()
-echo n2.toJson()
-
-let s1 = n1.toJson().fromJson(Nimib)
-echo s1.toJson()
-let s2 = n2.toJson().fromJson(Nimib)
-echo s2.toJson()
\ No newline at end of file
diff --git a/sandbox/hugoop/two.nim b/sandbox/hugoop/two.nim
deleted file mode 100644
index a976dce..0000000
--- a/sandbox/hugoop/two.nim
+++ /dev/null
@@ -1,51 +0,0 @@
-import jsony, tables
-
-type
-  Nimib = ref object of RootObj
-    a, b, c: int
-    typename: string
-  NimibChild = ref object of Nimib
-    d, e: float
-
-method dump(n: Nimib): string =
-  n[].toJson()
-
-method dump(n: NimibChild): string =
-  n[].toJson()
-
-proc dumpHook*(s: var string, v: Nimib) =
-  s.add v.dump()
-
-let n1: Nimib = Nimib(a: 1, b: 2, c: 3, typename: "Nimib")
-let n2: Nimib = NimibChild(a: 100, d: 3.14, e: 4.56, typename: "NimibChild")
-
-echo n1.toJson()
-echo n2.toJson()
-
-proc parseNimib(s: string, i: var int): Nimib =
-  var v = Nimib()
-  parseHook(s, i, v[])
-  result = v
-
-proc parseNimibChild(s: string, i: var int): Nimib =
-  var v = NimibChild()
-  parseHook(s, i, v[])
-  result = v
-
-let parseDefs = {
-  "Nimib": parseNimib,
-  "NimibChild": parseNimibChild
-}.toTable()
-
-proc parseHook*(s: string, i: var int, v: var Nimib) =
-  var n: Nimib = Nimib()
-  let current_i = i
-  parseHook(s, i, n[])
-  i = current_i
-  let typename = n.typename
-  v = parseDefs[typename](s, i)
-
-let s1 = n1.toJson().fromJson(Nimib)
-echo s1.toJson()
-let s2 = n2.toJson().fromJson(Nimib)
-echo s2.toJson()
\ No newline at end of file
diff --git a/sandbox/minib/capture.nim b/sandbox/minib/capture.nim
deleted file mode 100644
index c3884f2..0000000
--- a/sandbox/minib/capture.nim
+++ /dev/null
@@ -1,30 +0,0 @@
-## This submodule implements only one template to temporarily redirect and capture stdout during execution of a chunk of code.
-import tempfile
-
-# see https://stackoverflow.com/questions/64026829/how-to-temporarily-capture-stdout
-# Thanks, Clonk!
-
-# low level, should be Posix only but they happen to work on (my) Windows, too!
-proc dup(oldfd: FileHandle): FileHandle {.importc, header: "unistd.h".}
-proc dup2(oldfd: FileHandle, newfd: FileHandle): cint {.importc, header: "unistd.h".}
-
-template captureStdout*(ident: untyped, body: untyped) =
-  ## redirect stdout to a temporary file and captures output of body in ident
-  let
-    # Duplicate stdout
-    stdoutFileno = stdout.getFileHandle()
-    stdoutDupfd = dup(stdoutFileno)
-    # Create a new temporary file
-    (tmpFile, tmpFilename) = mkstemp(mode=fmWrite)
-    tmpFileFd: FileHandle = tmpFile.getFileHandle()  
-  discard dup2(tmpFileFd, stdoutFileno)  # writing to stdoutFileno now writes to tmpFile
-
-  body
-  flushFile stdout
-
-  # before reading tmpFile, flush and close
-  tmpFile.flushFile()  
-  tmpFile.close()
-  ident = readFile(tmpFileName)
-  # Restore stdout
-  discard dup2(stdoutDupfd, stdoutFileno)
\ No newline at end of file
diff --git a/sandbox/minib/jsutils.nim b/sandbox/minib/jsutils.nim
deleted file mode 100644
index de17e93..0000000
--- a/sandbox/minib/jsutils.nim
+++ /dev/null
@@ -1,228 +0,0 @@
-import std / [macros, macrocache, tables, strutils, strformat, sequtils, sugar, os, hashes]
-
-proc contains(tab: CacheTable, keyToCheck: string): bool =
-  for key, val in tab:
-    if key == keyToCheck:
-      return true
-  return false
-
-const bodyCache = CacheTable"bodyCache"
-
-macro addBody(key: string, s: untyped): untyped =
-  if key.strVal notin bodyCache:
-    bodyCache[key.strVal] = s
-
-proc degensymAst(n: NimNode) =
-  for i in 0 ..< n.len:
-    case n[i].kind
-    of nnkIdent, nnkSym:
-      let str = n[i].strVal
-      if "`gensym" in str:
-        let newStr = str.split("`gensym")[0]
-        let newSym = ident(newStr)
-        n[i] = newSym
-    else:
-      degensymAst(n[i])
-
-proc genCapturedAssignment(capturedVariables, capturedTypes: seq[NimNode]): tuple[code: NimNode, placeholders: seq[NimNode]] =
-  result.code = newStmtList()
-  # generate fromJSON loading and then add entire body afterwards
-  if capturedVariables.len > 0:
-    for (cap, capType) in zip(capturedVariables, capturedTypes):
-      let placeholder = gensym(ident="placeholder")
-      
-      let newSym = cap
-      result.placeholders.add placeholder
-      result.code.add quote do:
-        let `newSym` = parseJson(`placeholder`).to(`capType`) # we must gensym `cap` as well!
-
-macro nimToJsStringSecondStage*(key: static string, putCodeInBlock: static bool, captureVars: varargs[typed]): untyped =
-  let captureVars = toSeq(captureVars)
-
-  let captureTypes = collect:
-    for cap in captureVars:
-      cap.getTypeInst
-
-  # Get the untyped body from CacheTable
-  var body: NimNode
-  if key in bodyCache:
-    body = bodyCache[key]
-  else:
-    error(&"Nimib error: key {key} not in any of the tables. Please open an issue on Github with a minimal reproducible example")
-  # Now we have the body!
-  body = body.copyNimTree()
-  # 1. Generate the captured variable assignments and return placeholders
-  let (capAssignments, placeholders) = genCapturedAssignment(captureVars, captureTypes)
-  # 2. Stringify code
-  var code = newStmtList(capAssignments, body).copyNimTree()
-  code.degensymAst()
-
-  if putCodeInBlock:
-    code = newBlockStmt(code)
-  var codeText = code.toStrLit
-  # 3. Generate code which does the serialization and replacement of placeholders
-  let codeTextIdent = genSym(NimSymKind.nskVar, ident="codeText")
-  result = newStmtList()
-  result.add newVarStmt(codeTextIdent, codeText)
-  for i in 0 .. captureVars.high:
-    let placeholder = placeholders[i].repr.newLit
-    let varIdent = captureVars[i]
-    let serializedValue = quote do:
-      $(toJson(`varIdent`))
-    result.add quote do:
-      `codeTextIdent` = `codeTextIdent`.replace(`placeholder`, "\"\"\"" & `serializedValue` & "\"\"\"")
-  # return tuple of the transformed code to be compiled and the prettified code for visualization
-  body.degensymAst() # remove `gensym if code was written in a template
-  result.add nnkTupleConstr.newTree(codeTextIdent, body.toStrLit)
-    
-macro nimToJsString*(putCodeInBlock: static bool, args: varargs[untyped]): untyped =
-  if args.len == 0:
-    error("nbJsFromCode needs a code block to be passed", args)
-
-  let body = args[^1]
-  let captureVars =
-    if args.len == 1:
-      @[]
-    else:
-      args[0 ..< ^1]
-  
-  # Save UNTYPED body for access later. 
-  # It's important that it is untyped to be able to combine
-  # multiple code snippets.
-  let key = body.repr
-
-  result = newStmtList()
-  result.add quote do:
-    addBody(`key`, `body`)
-  var nextArgs = @[newLit(key), newLit(putCodeInBlock)]
-  nextArgs.add captureVars
-  result.add newCall("nimToJsStringSecondStage", nextArgs)
-
-macro nbKaraxCodeBackend*(rootId: untyped, args: varargs[untyped]) =
-  if args.len == 0:
-    error("nbKaraxCode needs a code block to be passed", args)
-  
-  let body = args[^1]
-  let captureVars =
-    if args.len == 1:
-      @[]
-    else:
-      args[0 ..< ^1]
-  
-  let newBody = quote do:
-    import karax / [kbase, karax, karaxdsl, vdom, compact, jstrutils, kdom]
-
-    var postRenderCallback: proc () = nil
-
-    template postRender(body: untyped) =
-      ## Must be called before karaxHtml!!!
-      proc tempProc () =
-        body
-      postRenderCallback = tempProc
-
-    template karaxHtml(body: untyped) =
-      proc createDom(): VNode =
-        result = buildHtml(tdiv):
-          body # html karax code
-      setRenderer(createDom, root=`rootId`.cstring, clientPostRenderCallback = postRenderCallback)
-
-    `body`
-
-  var callArgs = @[rootId]
-  callArgs.add captureVars
-  callArgs.add newBody
-
-  let call = newCall(ident"nbJsFromCodeOwnFile", callArgs)
-
-  result = call
-
-macro nbHappyxCodeBackend*(rootId: untyped, args: varargs[untyped]) =
-  if args.len == 0:
-    error("nbHappyxCode needs a code block to be passed", args)
-  let body = args[^1]
-  let captureVars =
-    if args.len == 1:
-      @[]
-    else:
-      args[0 ..< ^1]
-
-  let caller = body[^1][0]
-  if caller != ident"happyxRoutes":
-    error(fmt "{caller} != happyxRoutes: a happyxRoutes: block must terminate the nbHappyxCode block")
-
-  let happyxRoutesBody = body[^1][1]
-
-  let preHappyxRoutes =
-    if body.len == 1:
-      @[]
-    else:
-      body[0 ..< ^1]
-
-  var preRoutesCode = newStmtList()
-  for i in preHappyxRoutes.items:
-    preRoutesCode.add(i)
-
-  let imports = quote do:
-    import happyx, std/ strformat
-
-  let newBody = quote do:
-    `imports`
-    `preRoutesCode`
-    appRoutes(`rootId`):
-      `happyxRoutesBody`
-
-  var callArgs = @[rootId]
-  callArgs.add captureVars
-  callArgs.add newBody
-
-  let call = newCall(ident"nbJsFromCodeOwnFile", callArgs)
-  result = call
-
-#[ proc compileNimToJs*(doc: var NbDoc, blk: var NbBlock) =
-  let tempdir = getTempDir() / "nimib"
-  createDir(tempdir)
-  let (dir, filename, ext) = doc.thisFile.splitFile()
-  let nimfile = dir / (filename & "_nbCodeToJs_" & $doc.newId() & ext).RelativeFile
-  let jsfile = tempdir / &"out{hash(doc.thisFile)}.js"
-  var codeText = blk.context["transformedCode"].vString
-  let nbJsCounter = doc.nbJsCounter
-  doc.nbJsCounter += 1
-  var bumpGensymString = """
-import std/[macros, json]
-
-macro bumpGensym(n: static int) =
-  for i in 0 .. n:
-    let _ = gensym()
-
-"""
-  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
-  codeText = bumpGensymString & codeText
-  writeFile(nimfile, codeText)
-  let kxiname = "nimib_kxi_" & $doc.newId()
-  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
-  if errorCode != 0:
-    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
-  removeFile(nimfile)
-  let jscode = readFile(jsfile)
-  removeFile(jsfile)
-  blk.output = jscode
-  blk.context["output"] = jscode
-
-proc nbCollectAllNbJs*(doc: var NbDoc) =
-  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
-  var code = ""
-  for blk in doc.blocks:
-    if blk.command == "nbJsFromCode":
-      if blk.context["putAtTop"].vBool:
-        topCode.add "\n" & blk.context["transformedCode"].vString
-      else:
-        code.add "\n" & blk.context["transformedCode"].vString
-  code = topCode & "\n" & code
-
-  if not code.isEmptyOrWhitespace:
-    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
-    var blk = NbBlock(command: "nbJsFromCodeOwnFile", code: code, context: newContext(searchDirs = @[], partials = doc.partials), output: "")
-    blk.context["transformedCode"] = code
-    doc.blocks.add blk
-    doc.blk = blk
- ]#
\ No newline at end of file
diff --git a/sandbox/minib/minib.nim b/sandbox/minib/minib.nim
deleted file mode 100644
index 316750d..0000000
--- a/sandbox/minib/minib.nim
+++ /dev/null
@@ -1,579 +0,0 @@
-# types.nim
-import std/[tables, os, strformat, hashes, macros, genasts, strutils, sequtils]
-import "$nim/compiler/pathutils"
-import print
-type
-  NbBlock = ref object of RootObj
-    kind: string
-  NbRenderFunc = proc (blk: NbBlock, nb: Nb): string {. noSideEffect .}
-  NbRender = object
-    funcs: Table[string, NbRenderFunc]
-  NbContainer = ref object of NbBlock
-    blocks: seq[NbBlock]
-  NbDoc = ref object of NbContainer
-    title: string
-    id: int
-    nbJsCounter: int
-  Nb = object
-    blk: NbBlock # last block processed
-    doc: NbDoc # could be a NbBlock but we could give more guarantees with a NbDoc
-    containers: seq[NbContainer] # current container
-    backend: NbRender # current backend
-
-# this needs to be know for all container blocks not sure whether to put it in types
-func render(nb: Nb, blk: NbBlock): string =
-  if blk.kind in nb.backend.funcs:
-    nb.backend.funcs[blk.kind](blk, nb)
-  else:
-    ""
-
-proc newId*(doc: var NbDoc): int =
-  ## Provides a unique integer each time it is called
-  result = doc.id
-  inc doc.id
-
-func blocksFlattened*(doc: NbContainer): seq[NbBlock] =
-  for blk in doc.blocks:
-    result.add blk
-    if blk of NbContainer:
-      result.add blk.NbContainer.blocksFlattened()
-
-# globals.nim
-var nbToJson: Table[string, proc (s: string, i: var int): NbBlock]
-var nbToHtml: NbRender # since we need it for json, let's make it also for html
-
-# jsons.nim
-import jsony
-
-template addNbBlockToJson*(kind: untyped) =
-  nbToJson[$kind] =
-    proc (s: string, i: var int): NbBlock =
-      var v: kind
-      new v
-      parseHook(s, i, v[])
-      result = v
-
-  method dump(n: kind): string =
-    n[].toJson()
-
-proc parseHook*(s: string, i: var int, v: var NbBlock) =
-  # First parse the typename
-  var n: NbBlock = NbBlock()
-  let current_i = i
-  parseHook(s, i, n[])
-  # Reset i
-  i = current_i
-  # Parse the correct type
-  let kind = n.kind
-  if kind notIn nbToJson:
-    raise ValueError.newException "cannot find kind in nbToJson: \"" & kind & '"' 
-  v = nbToJson[kind](s, i)
-
-method dump(n: NbBlock): string =
-    n[].toJson()
-
-proc dumpHook*(s: var string, v: NbBlock) =
-  s.add v.dump()
-
-template dumpKey(s: var string, v: string) =
-  const v2 = v.toJson() & ":"
-  s.add v2
-
-proc parseCallStmt(n: NimNode): tuple[lhs: string, rhs: NimNode] =
-  n.expectKind nnkCall
-  (n[0].strVal, n[1][0])
-
-# nimibSugar.nim
-macro newNbBlock(typeName: untyped, body: untyped): untyped =
-  # typeName is either `ident` or
-  # Infix
-  #   Ident "of"
-  #   Ident "nbImage"
-  #   Ident "NbBlock"
-
-  let (typeNameStr, parentType) =
-   if typeName.kind == nnkIdent:
-     (typeName.strVal, "NbBlock".ident)
-   else:
-     (typeName[1].strVal, typeName[2])
-
-  let capitalizedTypeName = typeNameStr.capitalizeAscii
-  let lowercasedTypeName = typeNameStr.toLower
-
-  # body is:
-  # StmtList
-  #   Call
-  #     Ident "url"
-  #     StmtList
-  #       Ident "string"
-  #   Call
-  #     Ident "burl"
-  #     StmtList
-  #       Asgn
-  #         Ident "int"
-  #         IntLit 1
-  #   Call
-  #     Ident "toHtml"
-  #     StmtList
-  #       DotExpr
-  #         Ident "blk"
-  #         Ident "url"
-
-  echo "Body:\n", body.treeRepr
-
-  var fields: seq[tuple[fieldName: string, fieldType: NimNode]]
-  var toHtmlBody: NimNode
-  body.expectKind(nnkStmtList)
-  for n in body:
-    let (name, body) = n.parseCallStmt()
-    if eqIdent(name, "toHtml"):
-      toHtmlBody = body
-    else:
-      fields.add (name, body)
-
-  var fieldsList = nnkRecList.newTree()
-  for (fName, fType) in fields:
-    fieldsList.add newIdentDefs(fName.ident, fType)
-  let typeDefinition = nnkTypeSection.newTree(nnkTypeDef.newTree(
-    capitalizedTypeName.ident,
-    newEmptyNode(), # generic
-    nnkRefTy.newTree(
-      nnkObjectTy.newTree(
-        newEmptyNode(), # pragma
-        nnkOfInherit.newTree(
-          parentType
-        ),
-        fieldsList
-      )
-    )
-  ))
-
-  echo "Type:\n", typeDefinition.repr
-
-  # Next: generate initializer with prefilled kind
-  # Be vary of how we write the kind. SHould it be normalized or exactly like the user wrote it?
-  # It's more predictable if it is like the user wrote it. But more reasonable to normalize it...
-
-  var procParams = @[capitalizedTypeName.ident] & toSeq(fieldsList.children)
-  var objectConstructor = nnkObjConstr.newTree(
-    capitalizedTypeName.ident
-  )
-  objectConstructor.add newColonExpr(ident"kind", capitalizedTypeName.newLit)
-  for (fName, _) in fields:
-    objectConstructor.add newColonExpr(fName.ident, fName.ident)
-  var procBody = newStmtList(objectConstructor)
-
-  var procName = ident("new" & capitalizedTypeName)
-  let initializer = newProc(procName, procParams, procBody)
-
-  echo "init:\n", initializer.repr
-
-  # Next: generate nbImageToHtml from toHtmlBody
-  let renderProcName = (lowercasedTypeName & "ToHtml").ident
-  let renderProc = genAst(name = renderProcName, body = toHtmlBody, blk = ident"blk", nb = ident"nb", typeName=capitalizedTypeName.ident):
-    proc name*(blk: NbBlock, nb: Nb): string =
-      let blk = typeName(blk)
-      body
-
-
-  # Next: generate these lines:
-  # nbToHtml.funcs["NbImage"] = nbImageToHtml
-  # addNbBlockToJson(NbImage)
-  # should we make this into a proc instead so it can be used in the non-sugar variant as well?
-  let hookAssignements = genAst(key = capitalizedTypeName.newLit, f = renderProcName, typeName = capitalizedTypeName.ident):
-    nbToHtml.funcs[key] = f
-    addNbBlockToJson(typeName)
-
-  result = newStmtList(
-    typeDefinition,
-    initializer,
-    renderProc,
-    hookAssignements
-  )
-
-  echo result.repr
-
-  #assert false
-
-# themes.nim
-import std / strutils
-
-func nbContainerToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbContainer
-  for b in blk.blocks:
-    result.add nb.render(b).strip & '\n'
-  result.strip
-# should I add this to the global object?
-
-func nbDocToHtml*(blk: NbBlock, nb: Nb): string =
-  "<!DOCTYPE html>\n" &
-  "<title>" & blk.NbDoc.title & "</title>\n" &
-  nbContainerToHtml(blk, nb)
-  
-addNbBlockToJson(NbDoc)
-
-# blocks.nim
-import std / macros
-
-proc add(nb: var Nb, blk: NbBlock) =
-  nb.blk = blk
-  if nb.containers.len == 0:
-    nb.doc.blocks.add blk
-  else:
-    nb.containers[^1].blocks.add blk
-
-template withContainer(nb: var Nb, container: NbContainer, body: untyped) =
-  nb.add container
-  nb.containers.add container
-  body
-  discard nb.containers.pop
-
-macro toStr*(body: untyped): string =
-  (body.toStrLit)
-
-# capture.nim
-import capture # imported from old nimib (new nimib does not run locally for me!)
-
-# nimib.nim
-import markdown
-import jsutils
-
-template nbInit* =
-  var nb {. inject .}: Nb
-  nb.doc = NbDoc(kind: "NbDoc", title: "a nimib document")
-  nbToHtml.funcs["NbDoc"] = nbDocToHtml
-  nb.backend = nbToHtml
-
-template nbSave* =
-  echo "saving"
-  nbCollectAllNbJs(nb)
-  echo nb.render nb.doc
-  writeFile("test.html", nb.render(nb.doc))
-
-# all other blocks are in a sense all custom blocks
-# we could add sugar for common block creation
-# type
-#   NbText = ref object of NbBlock
-#     text: string
-# template nbText*(ttext: string) =
-#   let blk = NbText(text: ttext, kind: "NbText")
-#   nb.add blk
-# func nbTextToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbText
-#   {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-#     markdown(blk.text, config=initGfmConfig())
-# nbToHtml.funcs["NbText"] = nbTextToHtml
-# addNbBlockToJson(NbText)
-
-newNbBlock(NbText):
-  text: string
-  toHtml:
-    {.cast(noSideEffect).}: # not sure why markdown is marked with side effects
-      markdown(blk.text, config=initGfmConfig())
-
-proc text*(nb: var Nb, text: string) =
-  let blk = newNbText(text=text)
-  nb.add blk
-
-template nbText(ttext: string) =
-  nb.text(ttext)
-
-# type
-#   NbImage = ref object of NbBlock
-#     url: string
-# template nbImage*(turl: string) =
-#   let blk = NbImage(url: turl, kind: "NbImage")
-#   nb.add blk
-# func nbImageToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbImage
-#   "<img src= '" & blk.url & "'>"
-# nbToHtml.funcs["NbImage"] = nbImageToHtml
-# addNbBlockToJson(NbImage)
-#[ the above could be shortened with sugar to:
-newNbBlock(nbImage):
-  url: string
-  toHtml:
-    "<img src= '" & blk.url & "'>"
-]#
-
-newNbBlock(nbImage):
-  url: string
-  toHtml:
-    "<img src= '" & blk.url & "'>"
-
-func image*(nb: var Nb, url: string) =
-  let blk = newNbImage(url=url)
-  nb.add blk
-
-template nbImage*(url: string) =
-  nb.image(url)
-
-# type
-#   NbDetails = ref object of NbContainer
-#     summary: string
-# template nbDetails*(tsummary: string, body: untyped) =
-#   let blk = NbDetails(summary: tsummary, kind: "NbDetails")
-#   nb.withContainer(blk):
-#     body
-
-# func nbDetailsToHtml*(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbDetails
-#   "<details><summary>" & blk.summary & "</summary>\n" &
-#   nbContainerToHtml(blk, nb) &
-#   "\n</details>"
-  
-# nbToHtml.funcs["NbDetails"] = nbDetailsToHtml
-# addNbBlockToJson(NbDetails)
-
-newNbBlock(nbDetails of NbContainer):
-  summary: string
-  toHtml:
-    "<details><summary>" & blk.summary & "</summary>\n" &
-    nbContainerToHtml(blk, nb) &
-    "\n</details>"
-
-template details*(nb: var Nb, tsummary: string, body: untyped) =
-  let blk = newNbDetails(summary=tsummary)
-  nb.withContainer(blk):
-    body
-
-template nbDetails*(tsummary: string, body: untyped) =
-  nb.details(tsummary):
-    body
-
-# type
-#   NbCode = ref object of NbBlock
-#     code: string
-#     output: string
-#     lang: string
-# func nbCodeToHtml(blk: NbBlock, nb: Nb): string =
-#   let blk = blk.NbCode
-#   "<pre><code class=\"" & blk.lang & "\">\n" &
-#   blk.code & '\n' &
-#   "</code></pre>\n" &
-#   "<pre>\n" &
-#   blk.output & '\n' &
-#   "</pre>"
-# nbToHtml.funcs["NbCode"] = nbCodeToHtml
-# addNbBlockToJson(NbCode)
-# template nbCode*(body: untyped) =
-#   let blk = NbCode(lang: "nim", kind: "NbCode")
-#   nb.add blk
-#   blk.code = toStr(body)
-#   captureStdout(blk.output):
-#     body
-
-newNbBlock(nbCode):
-  code: string
-  output: string
-  lang: string
-  toHtml:
-    "<pre><code class=\"" & blk.lang & "\">\n" &
-    blk.code & '\n' &
-    "</code></pre>\n" &
-    "<pre>\n" &
-    blk.output & '\n' &
-    "</pre>"
-
-template code*(nb: var Nb, body: untyped) =
-  let blk = newNbCode(code="", output="", lang="nim")
-  nb.add blk
-  blk.code = toStr(body)
-  captureStdout(blk.output):
-    body
-
-template nbCode*(body: untyped) =
-  nb.code:
-    body
-
-#[ type
-  NbJsFromCode = ref object of NbBlock
-    code: string
-    transformedCode: string
-    putAtTop: bool
-    showCode: bool
-func nbJsFromCodeToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbJsFromCode
-  if blk.showCode:
-    "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
-  else:
-    ""
-nbToHtml.funcs["NbJsFromCode"] = nbJsFromCodeToHtml
-addNbBlockToJson(NbJsFromCode) ]#
-
-newNbBlock(NbJsFromCode):
-  code: string
-  transformedCode: string
-  putAtTop: bool
-  showCode: bool
-  toHtml:
-    if blk.showCode:
-      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>"
-    else:
-      ""
-
-template jsFromCode*(nb: var Nb, args: varargs[untyped]) =
-  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = newNbJsFromCode(code=originalCode, transformedCode=transformedCode, putAtTop=false, showCode=false)
-  nb.add blk
-
-template nbJsFromCode*(args: varargs[untyped]) =
-  nb.jsFromCode(args)
-
-#[ type
-  NbJsFromCodeOwnFile = ref object of NbBlock
-    code: string
-    transformedCode: string
-    jsCode: string
-    showCode: bool
-func nbJsFromCodeOwnFileToHtml(blk: NbBlock, nb: Nb): string =
-  let blk = blk.NbJsFromCodeOwnFile
-  result =
-    if blk.showCode:
-      "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
-    else:
-      ""
-  result &= &"<script>\n{blk.jsCode}\n</script>"
-nbToHtml.funcs["NbJsFromCodeOwnFile"] = nbJsFromCodeOwnFileToHtml
-addNbBlockToJson(NbJsFromCodeOwnFile) ]#
-
-newNbBlock(NbJsFromCodeOwnFile):
-  code: string
-  transformedCode: string
-  jsCode: string
-  showCode: bool
-  toHtml:
-    result =
-      if blk.showCode:
-        "<pre><code class=\"nim\">\n" & blk.code & "\n</code></pre>\n"
-      else:
-        ""
-    result &= &"<script>\n{blk.jsCode}\n</script>"
-
-template jsFromCodeOwnFile*(nb: var Nb, args: varargs[untyped]) =
-  let (transformedCode, originalCode) = nimToJsString(putCodeInBlock=false, args)
-  let blk = NbJsFromCodeOwnFile(code: originalCode, transformedCode: transformedCode, showCode: false, kind: "NbJsFromCodeOwnFile")
-  nb.add blk
-
-template nbJsFromCodeOwnFile*(args: varargs[untyped]) =
-  nb.jsFromCodeOwnFile(args)
-
-# jsutils.nim (these currently require to know of NbJsFromCode and NbJsFromCodeOwnFile...)
-proc compileNimToJs*(nb: var Nb, blk: NbBlock): string =
-  let blk = blk.NbJsFromCodeOwnFile
-  let tempdir = getTempDir() / "nimib"
-  createDir(tempdir)
-  let (dir, filename, ext) = (getCurrentDir().AbsoluteDir, "js_file", ".nim")#doc.thisFile.splitFile()
-  let nimfile = dir / (filename & "_nbCodeToJs_" & $nb.doc.newId() & ext).RelativeFile
-  let jsfile = tempdir / &"out{hash(nb.doc.title)}.js"
-  var codeText = blk.transformedCode
-  let nbJsCounter = nb.doc.nbJsCounter
-  nb.doc.nbJsCounter += 1
-  var bumpGensymString = """
-import std/[macros, json]
-
-macro bumpGensym(n: static int) =
-  for i in 0 .. n:
-    let _ = gensym()
-
-"""
-  bumpGensymString.add &"bumpGensym({nbJsCounter})\n"
-  codeText = bumpGensymString & codeText
-  writeFile(nimfile, codeText)
-  let kxiname = "nimib_kxi_" & $nb.doc.newId()
-  let errorCode = execShellCmd(&"nim js -d:danger -d:kxiname=\"{kxiname}\" -o:{jsfile} {nimfile}")
-  if errorCode != 0:
-    raise newException(OSError, "The compilation of a javascript file failed! Did you remember to capture all needed variables?\n" & $nimfile)
-  removeFile(nimfile)
-  let jscode = readFile(jsfile)
-  removeFile(jsfile)
-  return jscode
-
-proc nbCollectAllNbJs*(nb: var Nb) =
-  var topCode = "" # placed at the top (nbJsFromCodeGlobal)
-  var code = ""
-  for blk in nb.doc.blocksFlattened:
-    if blk of NbJsFromCode:
-      let blk = blk.NbJsFromCode
-      if blk.putAtTop:
-        topCode.add "\n" & blk.transformedCode
-      else:
-        code.add "\n" & blk.transformedCode
-  code = topCode & "\n" & code
-
-  if not code.isEmptyOrWhitespace:
-    # Create block which which will compile the code when rendered (nbJsFromJsOwnFile)
-    let blk = NbJsFromCodeOwnFile(kind: "NbJsFromCodeOwnFile", code: "", transformedCode: code, showCode: false)
-    nb.add blk
-
-  # loop over all nbJsFromCodeOwnFile and compile them
-  for blk in nb.doc.blocksFlattened:
-    if blk of NbJsFromCodeOwnFile:
-      var blk = blk.NbJsFromCodeOwnFile
-      blk.jsCode = nb.compileNimToJs(blk)
-
-
-when isMainModule:
-  import print
-  nbInit
-  nbDetails("Click for details:"):
-    nbText: "*hi*"
-    nbImage("img.png")
-    nbDetails("go deeper"):
-      nbText("42")
-  nbCode:
-    echo "hi"
-  nb.code:
-    echo "nb.code"
-  nbDetails("Hide js code:"):
-    nbJsFromCode:
-      echo "bye!"
-  nbSave
-  #[
-<!DOCTYPE html>
-<title>a nimib document<title>
-<details><summary>Click for details:</summary>
-<p><em>hi</em></p>
-<img src= 'img.png'>
-<details><summary>go deeper</summary>
-<p>42</p>
-</details>
-</details>
-<pre><code class="nim">
-
-echo "hi"
-</code></pre>
-<pre>
-hi
-
-</pre>
-  ]#
-
-  let docToJson = nb.doc.toJson()
-  print docToJson
-  let docFromJson = docToJson.fromJson(NbDoc) # but now this fails
-  print docFromJson
-  print docFromJson.blocks[0].NbDetails
-  print docFromJson.blocks[0].NbDetails.blocks[0].NbText
-  print docFromJson.blocks[0].NbDetails.blocks[1].NbImage
-  print docFromJson.blocks[1].NbCode
-  print docFromJson.blocks[2].NbCode
-  print docFromJson.blocks[3].NbDetails.blocks[0].NbJsFromCode
-  print docFromJson.blocks[4].NbJsFromCodeOwnFile
-  #[
-  docToJson="{"title":"a nimib document","blocks":[{"summary":"Click for details:","blocks":[{"text":"*hi*","kind":"NbText"},{"url":"img.png","kind":"NbImage"},{"summary":"go deeper","blocks":[{"text":"42","kind":"NbText"}],"kind":"NbDetails"}],"kind":"NbDetails"},{"code":"\\necho \\"hi\\"","output":"hi\\n","lang":"nim","kind":"NbCode"}],"kind":"NbDoc"}"
-docFromJson=NbDoc:ObjectType(
-  title: "a nimib document",
-  blocks: @[NbBlock:ObjectType(kind: "NbDetails"), NbBlock:ObjectType(kind: "NbCode")],
-  kind: "NbDoc"
-)
-docFromJson.blocks[0].NbDetails=NbDetails:ObjectType(
-  summary: "Click for details:",
-  blocks: @[NbBlock:ObjectType(kind: "NbText"), NbBlock:ObjectType(kind: "NbImage"), NbBlock:ObjectType(kind: "NbDetails")],
-  kind: "NbDetails"
-)
-docFromJson.blocks[0].NbDetails.blocks[0].NbText=NbText:ObjectType(text: "*hi*", kind: "NbText")
-docFromJson.blocks[0].NbDetails.blocks[1].NbImage=NbImage:ObjectType(url: "img.png", kind: "NbImage")
-docFromJson.blocks[1].NbCode=NbCode:ObjectType(code: "\necho "hi"", output: "hi\n", lang: "nim", kind: "NbCode")
-  ]#
-
diff --git a/sandbox/nim.cfg b/sandbox/nim.cfg
deleted file mode 100644
index 0b88f6e..0000000
--- a/sandbox/nim.cfg
+++ /dev/null
@@ -1,2 +0,0 @@
---hints:off
---warnings:off
\ No newline at end of file
diff --git a/sandbox/notes.md b/sandbox/notes.md
deleted file mode 100644
index d76a6a2..0000000
--- a/sandbox/notes.md
+++ /dev/null
@@ -1,230 +0,0 @@
-## getting back working on this
-
-### Next steps:
-- implement `nbCode` in minib [x]
-  - add (old!) implementation of captureStdout to minib / capture [x]
-- implement `nbCodeFromJs` in minib
-- think if there are essentially other types of blocks we need to test with the new refactoring
-- if not go ahead and implement sugar to implement custom blocks (and refactor)
-- clean up minib implementation
-  - remove previous minibs and rename minib3 to minib [x]
-- reimplement all of minib starting with the new minib poc
-
-### containers 👌
-- added NbContainer type, refactored NbDoc added NbDetails as example
-- FAILURE: serialization to json has issues!
-- alternative implementation of containers that does not use circular references
-  (simpler, no issues) [x]
-  - add api a `nb.add` and `nb.withContainer(container)
-: body`
-- hidden nb.blk api in nb.add (we might remove it later) [x]
-
----
-
-## Naming
-
-- not sure I still like the name backend for the rendering engine
-  that changes from blocks to string (and could be a themed html, a json, markdown...)
-
-### notes on backends
-
-- I could implement specific behaviours:
-  - markdown backend defaults to html backend when not defined
-  - html backend could default to a commented json output when not defined
-  - json backend should always be defined
-    - but stuff can be marked as to be skipped, e.g. the default theme should not be serialized
-
-## Fifth day - March 2nd
-
-what could I work on:
-- on theme
-  - use the minimal theme
-  - use a theme field that is skipped dring json generation
-- on container blocks
-  - implement summary details
-  - implement a flexbox container!
-    - that and a generic styled span container could allow me to easily create a grid...
-- for later
-  - md backend (and revision of backends)
-  - nbCode
-  - nbJs stuff
-
-more thoughts:
-- can I also use a super method or something to wrap the rendered block in a NbBlock?
-  - for example it could be used to add a class name inside a div
-    - this could be important for example to customize code block appearance
-  - or to add an optional id to a block
-  - (this could anyway be added later)
-  - and it could be added as something that by default a block does during rendering
-  - it might have a different signature (takes rendering of content and outputs new rendering)
-- restriction/variation of render method should be done towards the end,
-  so that I know what multiple blocks should be able to 
-- instead of passing Nb object to render method I could pass a pointer to the current render backend
-  - one could use this to do fun stuff, for example have a container block that chnages the rendering engine, I could show the output of json backend inside a html backend as raw json and so on
-  - oooh coool!
-
-## Notes from Fourth day - Match 1st
-
-Some notes for me for later while I am on mobile related to NbRender type:
-- right now NbDoc forced me to change the signature to add also Nb object
-- I think I should change to pass only NbDoc object (type of the root object)
-- also I could have NbRender support two types of functions (one for NbDoc like blocks one for NbText like blocks)
-- I should encode the block type in the base block
-- the general idea is to make the internal api safer (allow only what needs to be allowed)
-- also the idea is to have the NbDoc the unit of serialization and rendering should not access anything outside of that (it will not be accessible from a deserialized version)
-- and in NbDoc the plan is to have a theme field that is skipped on json serialization
-- there is a tension between what you want to be able to serialize (content and specificities of a page) and what you want to be controlled (later) by the SSG (like the theme) and should not be serialized (also because it is redundant). Tension also with a third element which is the fact that rendering does need a theme
-- as another, unrelated note, minimal theme could contain only doctype html and title element (see https://unplannedobsolescence.com/blog/best-hello-world-web-development/)
-
-## Third day - Feb 29
-
-- goal: add json backend
-- useful distraction: added a potential idea for sugar for creating blocks
-- interesting question: now NbDoc is special, what if I make it non special?
-- an idea I am realizing:
-  - all side effects should happen during block creation
-  - block rendering should be kept pure
-  - in particular this means that block that need an id from global nb object need to generate it at block creation time!
-- reminder for later: to fully support custom container blocks I will need to add in
-  Nb object something that tells me where to add next block
-- removed minilib, not useful since I would need import and that's a different problem
-
-todo:
-- [x] restructured minib and added sugar for blocks
-- [x] json backend (hugo's work is great!)
-
-## Second day - Feb 28
-
-- [x] review Hugo solution for oop
-- [x] define a scope and make explicit goals and assumptions
-- answer why OOP question
-- start working on it, starting from api
-
-### scope
-
-- blocks:
-  - nbBlock
-  - nbCode, nbText, nbImage, nbSummaryDetails
-- commands:
-  - nbInit, nbSave
-- output on save:
-  - a basic html document with water.css
-- support all 3 backends: html, json, md
-- support 2 themes: default, debug (json in html)
-- capture? maybe but no capture blocks inside other capture blocks
-- try to minimize use of external templating system
-  - pluggable templating system?
-
-### minib3
-
-implementation of above scope, structure:
-- minib: main library and example
-- minilib: non focus code that comes from existing nimib
-
-todo:
-- [x] structure
-- [x] implement nbText, nbImage
-- [x] implement nbSave (html backend, default theme, echo to terminal)
-  - [x] refactor NbDoc as NbBlock and add Nb object
-  - [x] NbRender and NbRenderFunc
-  - [x] single backend (for now)
-  - [x] nb.render blk
-  - [x] nbImageToHtml
-  - [x] nbTextToHtml
-  - [x] nbDocToHtml
-- [x] implement json backend
-- later:
-  - md backend
-  - nbCode, nbSummaryDetails
-  - sugar for block creation
-  - ...
-
-decisions:
-- 1) what do I pass to the render function?
-  - docs and any container block will need the full backend
-  - currently passing the whole Nb object but it might be an overkill
-- 2) where is the default backend defined?
-  - currently in Nb object (same as before)
-
-
-#### key understanding
-
-- I think I want to make NbDoc a NbBlock and basically remove the mustache templating!
-  (could still be reintroduced in a NbLegacyDoc for compatibility reasons)
-
-## Pair programming session - Feb 26
-
-GOALS of TODAY: pair program, get ideas and motivation.
-Achieved.
-
-Main highlights:
-- why I want to do OOP? need to be able to answer that
-- start from API (in particular locality of definition of blocks)
-- define a Scope of what I want to support
-- is this an extension of a templating system?
-
-### details
-
-preparation
-
-annoying:
-- just noticed that this PR broke locally my tests: https://github.com/pietroppeter/nimib/pull/211/files
-- I am still using 1.6! not good!
-- still do not have a way to switch easily
-
-plan for today:
-- this is a summary of nimib and refactoring: https://gist.github.com/pietroppeter/0a3699531c8059eea9094e076ac15f9f
-- discuss and see critical points
-- if we manage to code stuff, better
-
-plan:
-- let's start in a sandbox environment from scratch
-- a new NbBlock type
-- goals:
-  - support container blocks
-  - inheritance
-  - user can customize method (how? oop? or I just add a closure?)
-  - support json backend
-  - should work well with multi-language support
-    - might come from json backend
-  - improve locality of block definition
-- current mechanism
-  - does not support container blocks
-  - blocks are defined in two places
-- how to handle the customization of backend?
-  - willing to sacrifice this at the moment
-  - but ideally 
-- not in scope
-  - serialization and deserialization through jsony
-    - Hugo will take care of that
-
-
-
-discussion:
-- **decision**: base block should be a containers block?
-  - yes: you mimic html where every node can have children nodes
-  - (argument for no) if yes all blocks inheriting would need to take into account the children blocks in the templating
-  - example of nbImage: argument for no
-- idea: we could start with locality and start from api and work backwards
-
-
-what kind of blocks do we have:
-- a source block: where I need to capture the source code generating the block
-- a capturing block: where stdout is captured
-- a slim block: with no body
-- a block with body:
-  - body can be executed
-  - body can be discarded
-  - (body can be altered) - no example
-- a container block: that can contain other blocks inside
-- blocks can have side effects: e.g. write to a file, read from a file
-- needs rendering procs (postprocess), could be backend specific
-
-examples:
-- nbCode: source, capturing, withBody(executed), needs postprocess (highlighting)
-- nbText: slim block, needs postprocess (mdToHtml)
-- nbImage: slim block
-- nbSummaryDetails: container block
-
-a new minib:
-- skip capturing
\ No newline at end of file

From dd375c227d1c7ccda2473fc7e9b2364b17594555 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:09:54 +0100
Subject: [PATCH 70/73] strip code blocks to get rid of newlines at the end

---
 src/nimib/sources.nim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nimib/sources.nim b/src/nimib/sources.nim
index 7b7c448..e3742b4 100644
--- a/src/nimib/sources.nim
+++ b/src/nimib/sources.nim
@@ -168,4 +168,4 @@ macro getCodeAsInSource*(source: string, body: untyped): string =
     getCodeBlock(nb.doc.sourceFiles[`filename`], `startPosLit`, `endPosLit`)
 
 template getCode*(body: untyped): string =
-  getCodeAsInSource(nb.doc.source, body)
\ No newline at end of file
+  getCodeAsInSource(nb.doc.source, body).strip
\ No newline at end of file

From e0d92d35415fd883642d75132379b2d49ae951b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:10:27 +0100
Subject: [PATCH 71/73] build readme again

---
 README.md     | 20 +++-----------------
 nimib.nimble  |  5 +++--
 src/nimib.nim |  2 +-
 3 files changed, 7 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index ab4584f..72bb557 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,3 @@
-
 # nimib 🐳 - nim 👑 driven ⛵ publishing ✍
 
 Nimib provides an API to convert your Nim code and its outputs to html documents.
@@ -50,8 +49,6 @@ provides syntax highlighting of embedded languages in nimib documents (eg. markd
 First have a look at the following html document: [hello.html](https://pietroppeter.github.io/nimib/hello.html)
 
 This was produced with `nim r docsrc/hello`, where [docsrc/hello.nim](https://github.com/pietroppeter/nimib/blob/main/docsrc/hello.nim) is:
-
-
 ```nim
 import strformat, strutils
 import nimib
@@ -100,8 +97,6 @@ nbText:
 nbSave
 
 ```
-
-
 ### Other examples of usage
 
 in this repo:
@@ -228,16 +223,11 @@ that allow to override the above value, skip the config file or other options.
 
 All the options available can be seen by running any nimib file with option `nbHelp`
 (execution will stop after `nbInit`).
-
-
-
 ```nim
 import osproc
-withDir nb.srcDir:
+withDir nb.doc.srcDir:
   echo execProcess("nim r --verbosity:0 --hints:off --warnings:off hello --nbHelp")
 ```
-
-
 ```
 Nimib options:
 
@@ -248,12 +238,9 @@ Nimib options:
   --nbHomeDir,  --nimibHomeDir              set homeDir as relative (to CfgDir) or absolute; overrides config 
   --nbFilename, --nimibFilename             overrides name of output file (e.g. somefile --nbFilename:othername.html)
   --nbShow,     --nimibShow                 open in browser at the end of nbSave
-```
-
-
-
 
 
+```
 The value of options are available in `nb.options` field which also
 tracks further options in `nb.options.other: seq[tuple[kind: CmdLineKind; name, value: string]]`.
 
@@ -371,5 +358,4 @@ because I made a [package](https://github.com/pietroppeter/nimoji) for that and
 ### why the Q & A?
 
 because [someone made it into an art form](https://github.com/oakes/vim_cubed#q--a)
-and they tell me [imitation is the sincerest form of flattery](https://www.goodreads.com/quotes/558084-imitation-is-the-sincerest-form-of-flattery-that-mediocrity-can)
-
+and they tell me [imitation is the sincerest form of flattery](https://www.goodreads.com/quotes/558084-imitation-is-the-sincerest-form-of-flattery-that-mediocrity-can)
\ No newline at end of file
diff --git a/nimib.nimble b/nimib.nimble
index 38ac5df..850b6a3 100644
--- a/nimib.nimble
+++ b/nimib.nimble
@@ -29,8 +29,9 @@ task readme, "update readme":
 
 task docs, "Build documentation":
   for file in ["allblocks", "hello", "mostaccio", "numerical", "nolan",
-    "pythno", "index", "cheatsheet", "files", "interactivity", "counters", "caesar"]:
+    "pythno", "cheatsheet", "files", "index",
+    "interactivity", "counters", "caesar"]:
     exec "nim r --hints:off docsrc/" & file & ".nim"
   when not defined(nimibDocsSkipPenguins):
     exec "nim r --hints:off docsrc/penguins.nim"
-  #exec "nimble readme"  
+  exec "nimble readme"  
diff --git a/src/nimib.nim b/src/nimib.nim
index ec2f150..7054618 100644
--- a/src/nimib.nim
+++ b/src/nimib.nim
@@ -68,7 +68,7 @@ template nbInitMd*(thisFileRel = "") =
 
   nbInit(renderer=nbToMd, theme=themes.noTheme, tfr)
 
-  if nb.options.filename == "":
+  if nb.doc.options.filename == "":
     nb.doc.filename = nb.doc.filename.splitFile.name & ".md"
 
 #[ # block generation templates

From c65b174f10838a78b6d953448fed6065145ae976 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:11:15 +0100
Subject: [PATCH 72/73] fix trailing whitespace in withNewlines

---
 src/nimib/nimibSugars.nim | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/nimib/nimibSugars.nim b/src/nimib/nimibSugars.nim
index 2f1bb04..c8ae49d 100644
--- a/src/nimib/nimibSugars.nim
+++ b/src/nimib/nimibSugars.nim
@@ -194,20 +194,23 @@ macro newNbBlock*(typeName: untyped, body: untyped): untyped =
 
 macro withNewlines*(body: untyped) : string =
   body.expectKind nnkStmtList
-  result = body[0]
-  if result.kind == nnkIfStmt and result.findChild(it.kind == nnkElse).isNil:
-    result.add nnkElse.newTree("".newLit)
-  result = infix(result, "&", "\n".newLit)
-  if body.len > 1:
-    for line in body[1..^1]:
+  result = "".newLit
+  if body.len > 0:
+    for i, line in body:
       # TODO: handle for loops
       # if it's an if-statement, check if it has an else-clause. Otherwise add one which returns ""
       if line.kind == nnkIfStmt and line.findChild(it.kind == nnkElse).isNil:
         line.add nnkElse.newTree("".newLit)
-      result = infix(result, "&", line)
-      result = infix(result, "&", "\n".newLit)
-  #echo result.treerepr
-  #echo result.repr
+      
+      # Only add a newline if the line contains anything and isn't the last line
+      # Also if it already ends with a newline we don't have to add one
+      result = genAst(result=result, line=line, isLast=newLit(i==body.len-1)):
+        let lineVal = line
+        if not isLast and lineVal.len > 0 and lineVal[^1] != '\n':
+          result & lineVal & "\n"
+        else:
+          result & lineVal
+
 
   
 

From 44feda93951820324e26d53cb8ef2337c0c2cc37 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hugo=20Granstr=C3=B6m?=
 <5092565+HugoGranstrom@users.noreply.github.com>
Date: Sat, 1 Nov 2025 12:19:12 +0100
Subject: [PATCH 73/73] fix tests

---
 tests/tblocks.nim  |  2 +-
 tests/tnimib.nim   |  4 ++--
 tests/trenders.nim | 16 ++++------------
 3 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/tests/tblocks.nim b/tests/tblocks.nim
index 8f1cc2f..a812af3 100644
--- a/tests/tblocks.nim
+++ b/tests/tblocks.nim
@@ -17,6 +17,6 @@ suite "newNbBlock":
     readCodeBlock:
       let a = 1.23
 
-    check nb.blk.ReadCodeBlock.code == "let a = 1.23\n"
+    check nb.blk.ReadCodeBlock.code == "let a = 1.23"
 
 
diff --git a/tests/tnimib.nim b/tests/tnimib.nim
index 5d7e214..6b68962 100644
--- a/tests/tnimib.nim
+++ b/tests/tnimib.nim
@@ -137,7 +137,7 @@ suite "nbCodeSkip":
       echo "random output..."
 
     check nb.blk.NbCode.output == ""
-    check nb.blk.NbCode.code == "echo \"random output...\"\n"
+    check nb.blk.NbCode.code == "echo \"random output...\""
 
   test "destructive code":
     # Make sure the code is NOT executed
@@ -146,7 +146,7 @@ suite "nbCodeSkip":
       fail()
     
     check nb.blk.NbCode.output == ""
-    check nb.blk.NbCode.code == "fail()\n"
+    check nb.blk.NbCode.code == "fail()"
 
 suite "nbCapture":
   test "single line of code, with output":
diff --git a/tests/trenders.nim b/tests/trenders.nim
index 4ee2c79..7f03afa 100644
--- a/tests/trenders.nim
+++ b/tests/trenders.nim
@@ -16,7 +16,6 @@ suite "render (block), html default backend":
     nbCode: echo "hi"
     check nb.render(nb.blk).strip == """
 <pre><code class="nohighlight hljs nim"><span class="hljs-keyword">echo</span> <span class="hljs-string">&quot;hi&quot;</span></code></pre>
-
 <pre class="nb-output">hi
 </pre>"""
 
@@ -43,33 +42,26 @@ discard
 ```nim
 echo "hi"
 ```
-
 ```
 hi
-
 ```
-
 """.strip()
 
   test "nbImage with caption":
     nbImage("https://nim-lang.org/assets/img/logo_bw.png", "nim-lang.org favicon")
-    check nb.render(nb.blk) == """
+    check nb.render(nb.blk).strip == """
 ![nim-lang.org favicon](https://nim-lang.org/assets/img/logo_bw.png)
-
 **Figure:** nim-lang.org favicon
-
-"""
+""".strip
 
   test "nbImage without caption":
     nbImage("https://nim-lang.org/assets/img/logo_bw.png")
     check nb.render(nb.blk) == """
 ![](https://nim-lang.org/assets/img/logo_bw.png)
-
 """
 
   test "nbImage with alt text":
     nbImage("https://nim-lang.org/assets/img/logo_bw.png", alt="nim-lang.org favicon")
-    check nb.render(nb.blk) == """
+    check nb.render(nb.blk).strip == """
 ![nim-lang.org favicon](https://nim-lang.org/assets/img/logo_bw.png)
-
-"""
+""".strip