Feat: add new Markdown parser (#39800)

and change all the challenges to new `md` format.

curriculum/challenges/english/10-coding-interview-prep/data-structures/create-a-circular-queue.md

@@ -5,10 +5,9 @@ challengeType: 1
 forumTopicId: 301625
 ---
 
-## Description
-<section id='description'>
+# --description--
 
-In this challenge you will be creating a Circular Queue. A circular queue is a queue that writes to the end of a collection then begins overwriting itself at the beginning of the collection. This type of data structure is useful in certain situations.  For example, a circular queue can be used for streaming media. Once the queue is full, new media data will overwrite old data.
+In this challenge you will be creating a Circular Queue. A circular queue is a queue that writes to the end of a collection then begins overwriting itself at the beginning of the collection. This type of data structure is useful in certain situations. For example, a circular queue can be used for streaming media. Once the queue is full, new media data will overwrite old data.
 
 A good way to illustrate this concept is with an array of length `5`:
 
@@ -34,7 +33,7 @@ As the read head reads, it can remove values or keep them:
                    ^Write @ 3
 ```
 
-Now we write the values `d`, `e`, and `f` to the queue.  Once the write reaches the end of the array it loops back to the beginning:
+Now we write the values `d`, `e`, and `f` to the queue. Once the write reaches the end of the array it loops back to the beginning:
 
 ```js
 [f, null, null, d, e]
@@ -43,39 +42,106 @@ Now we write the values `d`, `e`, and `f` to the queue.  Once the write reaches
 ```
 
 This approach requires a constant amount of memory but allows files of a much larger size to be processed.
-</section>
 
-## Instructions
-<section id='instructions'>
+# --instructions--
 
-In this challenge we will implement a circular queue. The circular queue should provide `enqueue` and `dequeue` methods which allow you to read from and write to the queue. The class itself should also accept an integer argument which you can use to specify the size of the queue when created. We've written the starting version of this class for you in the code editor. When you enqueue items to the queue, the write pointer should advance forward and loop back to the beginning once it reaches the end of the queue. Likewise, the read pointer should advance forward as you dequeue items. The write pointer should not be allowed to move past the read pointer (our class won't let you overwrite data you haven't read yet) and the read pointer should not be able to advance past data you have written.
-In addition, the `enqueue` method should return the item you enqueued if it is successful; otherwise it will return `null`. Similarly, when you dequeue an item, that item should be returned and if you cannot dequeue an item you should return `null`.
-</section>
+In this challenge we will implement a circular queue. The circular queue should provide `enqueue` and `dequeue` methods which allow you to read from and write to the queue. The class itself should also accept an integer argument which you can use to specify the size of the queue when created. We've written the starting version of this class for you in the code editor. When you enqueue items to the queue, the write pointer should advance forward and loop back to the beginning once it reaches the end of the queue. Likewise, the read pointer should advance forward as you dequeue items. The write pointer should not be allowed to move past the read pointer (our class won't let you overwrite data you haven't read yet) and the read pointer should not be able to advance past data you have written. In addition, the `enqueue` method should return the item you enqueued if it is successful; otherwise it will return `null`. Similarly, when you dequeue an item, that item should be returned and if you cannot dequeue an item you should return `null`.
 
-## Tests
-<section id='tests'>
+# --hints--
 
-```yml
-tests:
-  - text: The <code>enqueue</code> method should add items to the circular queue.
-    testString: assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); var print = test.print(); return print[0] === 17 && print[1] === 32 && print[2] === 591; })());
-  - text: You should not enqueue items past the read pointer.
-    testString: assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); test.enqueue(13); test.enqueue(25); test.enqueue(59); var print = test.print(); return print[0] === 17 && print[1] === 32 && print[2] === 591; })());
-  - text: The <code>dequeue</code> method should dequeue items from the queue.
-    testString: assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); return test.dequeue() === 17 && test.dequeue() === 32 && test.dequeue() === 591; })());
-  - text: After an item is dequeued, its position in the queue should be reset to <code>null</code>.
-    testString: assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(672); test.dequeue(); test.dequeue(); var print = test.print(); return print[0] === null && print[1] === null && print[2] === 672; })());
-  - text: Trying to dequeue past the write pointer should return <code>null</code> and does not advance the write pointer.
-    testString: assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); return test.dequeue() === 17 && test.dequeue() === 32 && test.dequeue() === 591 && test.dequeue() === null && test.dequeue() === null && test.dequeue() === null && test.dequeue() === null && test.enqueue(100) === 100 && test.dequeue() === 100; })());
+The `enqueue` method should add items to the circular queue.
 
+```js
+assert(
+  (function () {
+    var test = new CircularQueue(3);
+    test.enqueue(17);
+    test.enqueue(32);
+    test.enqueue(591);
+    var print = test.print();
+    return print[0] === 17 && print[1] === 32 && print[2] === 591;
+  })()
+);
 ```
 
-</section>
+You should not enqueue items past the read pointer.
 
-## Challenge Seed
-<section id='challengeSeed'>
+```js
+assert(
+  (function () {
+    var test = new CircularQueue(3);
+    test.enqueue(17);
+    test.enqueue(32);
+    test.enqueue(591);
+    test.enqueue(13);
+    test.enqueue(25);
+    test.enqueue(59);
+    var print = test.print();
+    return print[0] === 17 && print[1] === 32 && print[2] === 591;
+  })()
+);
+```
 
-<div id='js-seed'>
+The `dequeue` method should dequeue items from the queue.
+
+```js
+assert(
+  (function () {
+    var test = new CircularQueue(3);
+    test.enqueue(17);
+    test.enqueue(32);
+    test.enqueue(591);
+    return (
+      test.dequeue() === 17 && test.dequeue() === 32 && test.dequeue() === 591
+    );
+  })()
+);
+```
+
+After an item is dequeued, its position in the queue should be reset to `null`.
+
+```js
+assert(
+  (function () {
+    var test = new CircularQueue(3);
+    test.enqueue(17);
+    test.enqueue(32);
+    test.enqueue(672);
+    test.dequeue();
+    test.dequeue();
+    var print = test.print();
+    return print[0] === null && print[1] === null && print[2] === 672;
+  })()
+);
+```
+
+Trying to dequeue past the write pointer should return `null` and does not advance the write pointer.
+
+```js
+assert(
+  (function () {
+    var test = new CircularQueue(3);
+    test.enqueue(17);
+    test.enqueue(32);
+    test.enqueue(591);
+    return (
+      test.dequeue() === 17 &&
+      test.dequeue() === 32 &&
+      test.dequeue() === 591 &&
+      test.dequeue() === null &&
+      test.dequeue() === null &&
+      test.dequeue() === null &&
+      test.dequeue() === null &&
+      test.enqueue(100) === 100 &&
+      test.dequeue() === 100
+    );
+  })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
 
 ```js
 class CircularQueue {
@@ -110,12 +176,7 @@ class CircularQueue {
 }
 ```
 
-</div>
-</section>
-
-## Solution
-<section id='solution'>
-
+# --solutions--
 
 ```js
 class CircularQueue {
@@ -165,5 +226,3 @@ class CircularQueue {
   }
 }
 ```
-
-</section>