JS

david/2024/01/01/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/02/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/03/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/04/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/05/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/06/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/07/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/08/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/09/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/10/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/11/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/12/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/13/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/14/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/15/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/16/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/17/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/18/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/19/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/20/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/21/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/22/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/23/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/24/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/25/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/26/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/27/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/28/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/29/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/30/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/01/31/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/01/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/02/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/03/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/04/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/05/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/06/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/07/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/08/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/09/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/10/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/11/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/12/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/13/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/14/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/15/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/16/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/17/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/18/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/19/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/20/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/21/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/22/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/23/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/24/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/25/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/26/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/27/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/28/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/02/29/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/01/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/02/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/03/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/04/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/05/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/06/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/07/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/08/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/09/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/10/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/11/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/2024/03/12/index.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 

david/log/index.xml

     <link href="https://larlet.fr/david/" rel="alternate" type="text/html" />
     <link href="https://larlet.fr/david/log/" rel="self" />
     <id>https://larlet.fr/david/</id>
-    <updated>2024-03-12T12:00:00+01:00</updated>
+    <updated>2024-03-13T12:00:00+01:00</updated>
     <author>
         <name>David Larlet</name>
         <uri>https://larlet.fr/david/</uri>

david/templates/article_2024.html

   <script type="module">
     import { annotate } from '/static/david/js/rough-notation-0.5.1.esm.min.js'
 
-    const observer = new IntersectionObserver(elements => {
+    const markObserver = new IntersectionObserver((entries, observer) => {
       const computedStyle = getComputedStyle(document.documentElement)
       const markBackground = computedStyle.getPropertyValue('--mark-background')
-      for (const element of elements) {
-        if (element.intersectionRatio === 0) continue
-        const markElement = element.target
-        if (markElement.dataset.annotated) continue
+      for (const entry of entries) {
+        if (entry.intersectionRatio === 0) continue
+        const markElement = entry.target
         const annotation = annotate(
           markElement, {
             type: 'highlight',
           }
         )
         annotation.show()
-        // Avoid the rough notation to be applied multiple times.
-        markElement.dataset.annotated = true
+        observer.unobserve(markElement)
       }
     }, {threshold: 1.0})
 
     for (const markElement of document.querySelectorAll('mark')) {
       markElement.style.backgroundColor = 'inherit'
-      observer.observe(markElement)
+      markObserver.observe(markElement)
     }
   </script>
 {% endblock %}