JS (rough notation)

david/2024/01/01/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/02/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/03/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/04/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/05/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/06/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/07/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/08/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/09/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/10/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/11/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/12/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/13/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/14/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/15/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/16/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/17/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/18/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/19/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/20/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/21/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/22/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/23/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/24/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/25/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/26/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/27/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/28/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/29/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/30/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/01/31/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/01/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/02/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/03/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/04/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/05/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/06/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/07/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/08/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/09/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/10/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/11/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/12/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/13/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/14/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/15/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/16/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/17/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/18/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/19/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/20/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/21/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/22/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/23/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/24/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/25/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/26/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/27/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/28/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/02/29/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/01/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/02/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/03/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/04/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/05/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/06/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/07/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/08/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/09/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/10/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/2024/03/11/index.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 
   </body>
 </html>

david/templates/article_2024.html

       hideOnClick: false
     })
   </script>
+  <script type="module">
+    import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
+
+    const computedStyle = getComputedStyle(document.documentElement)
+    const markBackground = computedStyle.getPropertyValue('--mark-background')
+
+    const observer = new IntersectionObserver(elements => {
+      for (const element of elements) {
+        if (element.intersectionRatio < 1) return
+        const markElement = element.target
+        if (markElement.dataset.annotated) return
+        const annotation = annotate(
+          markElement, {
+            type: 'highlight',
+            multiline: true,
+            color: markBackground,
+            animate: !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+          }
+        )
+        annotation.show()
+        // Avoid the rough notation to be applied multiple times.
+        markElement.dataset.annotated = true
+      }
+    }, {threshold: 1.0})
+
+    for (const markElement of document.querySelectorAll('mark')) {
+      markElement.style.backgroundColor = 'inherit'
+      observer.observe(markElement)
+    }
+  </script>
 {% endblock %}