├── src
    ├── favicon.ico
    ├── package.json
    ├── muffin.grammar.in
    ├── editor.js
    ├── muffin.css
    ├── index.html
    ├── frontend.js
    ├── package-lock.json
    └── muffin.js
├── .gitignore
├── LICENSE
└── README.md


/src/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CBerJun/Muffin/HEAD/src/favicon.ico


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Dependencies
 2 | node_modules/
 3 | 
 4 | # My secret notes
 5 | /BRAINSTORM.txt
 6 | 
 7 | # Generated contents
 8 | /build
 9 | /dist
10 | /src/parser.js
11 | /src/autocomplete.js
12 | 


--------------------------------------------------------------------------------
/src/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "type": "module",
 3 |     "dependencies": {
 4 |         "@codemirror/autocomplete": "^6.18.3",
 5 |         "@codemirror/commands": "^6.1.2",
 6 |         "@codemirror/search": "^6.2.3",
 7 |         "@codemirror/theme-one-dark": "^6.1.0",
 8 |         "@codemirror/view": "^6.6.0",
 9 |         "@lezer/common": "^1.2.3",
10 |         "@lezer/generator": "^1.7.1",
11 |         "@lezer/highlight": "^1.2.1",
12 |         "@lezer/lr": "^1.4.2",
13 |         "@rollup/plugin-node-resolve": "^15.0.1",
14 |         "minify": "^9.1.0",
15 |         "rollup": "^3.5.1"
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/muffin.grammar.in:
--------------------------------------------------------------------------------
 1 | @top Program {
 2 |     Newline? recipe*
 3 | }
 4 | 
 5 | @skip {
 6 |     WS
 7 | }
 8 | 
 9 | known_keyword[@name=MiscKeyword] {
10 |     %misc_keywords%
11 | }
12 | 
13 | kw<term> { @specialize[@name=SpecialKeyword]<Keyword, term> }
14 | 
15 | known_identifier[@name=KnownIdentifier] {
16 |     %identifiers%
17 | }
18 | 
19 | step_content {
20 |     String
21 |     | Number
22 |     | Operators
23 |     | known_keyword
24 |     | known_identifier
25 |     | Keyword
26 |     | Identifier
27 | }
28 | 
29 | recipe_name[@name=RecipeName] {
30 |     (Identifier | known_identifier)+
31 | }
32 | 
33 | ingredient_body[@name=IngredientBody] {
34 |     kw<"ingredients"> Newline ingredient*
35 | }
36 | 
37 | step_body[@name=StepBody] {
38 |     kw<"method"> Newline step*
39 | }
40 | 
41 | recipe[@name=RecipeDef] {
42 |     recipe_name kw<"recipe"> Newline
43 |     ingredient_body
44 |     step_body
45 | }
46 | 
47 | ingredient_name[@name=IngredientName] {
48 |     (Identifier | known_identifier)+
49 | }
50 | 
51 | ingredient {
52 |     (Number | String) (known_keyword | Keyword)* ingredient_name Newline
53 | }
54 | 
55 | step {
56 |     Number step_content* Newline
57 | }
58 | 
59 | @tokens {
60 |     WS {
61 |         $[ \t]+
62 |     }
63 |     Newline {
64 |         $[\n]+ | @eof
65 |     }
66 |     String {
67 |         '"' !["\n]* '"'
68 |     }
69 |     Number {
70 |         @digit+ ($[CF.] | %ordinal%)?
71 |     }
72 |     Operators {
73 |         %operators%
74 |     }
75 |     Keyword {
76 |         @asciiLowercase $[a-zA-Z0-9_]*
77 |     }
78 |     Identifier {
79 |         @asciiUppercase $[a-zA-Z0-9_]*
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/editor.js:
--------------------------------------------------------------------------------
  1 | import { EditorState } from '@codemirror/state';
  2 | import { openSearchPanel, highlightSelectionMatches } from '@codemirror/search';
  3 | import { indentWithTab, history, defaultKeymap, historyKeymap } from '@codemirror/commands';
  4 | import { foldGutter, indentUnit, foldKeymap, LanguageSupport, LRLanguage, indentNodeProp } from '@codemirror/language';
  5 | import { autocompletion, completionKeymap, acceptCompletion, closeBrackets } from '@codemirror/autocomplete';
  6 | import {
  7 |     lineNumbers, highlightActiveLineGutter, drawSelection,
  8 |     rectangularSelection, crosshairCursor, highlightActiveLine, keymap,
  9 |     EditorView
 10 | } from '@codemirror/view';
 11 | import { oneDark } from "@codemirror/theme-one-dark";
 12 | import { parser } from "./parser.js";
 13 | import { styleTags, tags as t } from "@lezer/highlight";
 14 | import * as autocompleteData from "./autocomplete.js";
 15 | 
 16 | const muffinParser = parser.configure({
 17 |     props: [
 18 |         styleTags({
 19 |             "String": t.string,
 20 |             "Number": t.integer,
 21 |             "Operators": t.punctuation,
 22 |             "MiscKeyword": t.operatorKeyword,
 23 |             "SpecialKeyword": t.controlKeyword,
 24 |             "RecipeName/...": t.className,
 25 |             "IngredientName/...": t.atom,
 26 |             "KnownIdentifier": t.variableName,
 27 |         }),
 28 |         indentNodeProp.add({
 29 |             "IngredientBody StepBody": (context) =>
 30 |                 context.baseIndent + context.unit,
 31 |         }),
 32 |     ]
 33 |     // TODO folding
 34 | });
 35 | 
 36 | const muffinLanguage = LRLanguage.define({
 37 |     parser: muffinParser,
 38 |     languageData: {
 39 |         closeBrackets: {
 40 |             brackets: ['"'],
 41 |         },
 42 |     },
 43 | });
 44 | 
 45 | const kwRegexp = /\b([a-z]\w* )*\b[a-z]\w*/;
 46 | const idRegexp = /\b([A-Z]\w* )*\b[A-Z]\w*/;
 47 | 
 48 | const muffinCompletion = muffinLanguage.data.of({
 49 |     autocomplete: (context) => {
 50 |         // Determine if the user is trying to type a keyword (lowercase)
 51 |         // or an identifier (Title Case)
 52 |         const kwMatch = context.matchBefore(kwRegexp);
 53 |         let data;
 54 |         let from;
 55 |         let validFor;
 56 |         if (kwMatch) {
 57 |             data = autocompleteData.keywords;
 58 |             from = kwMatch.from;
 59 |             validFor = kwMatch;
 60 |         }
 61 |         else {
 62 |             const idMatch = context.matchBefore(idRegexp);
 63 |             if (idMatch) {
 64 |                 data = autocompleteData.identifiers;
 65 |                 from = idMatch.from;
 66 |                 validFor = idMatch;
 67 |             }
 68 |             else if (context.explicit) {
 69 |                 data = autocompleteData.allNames;
 70 |                 from = context.pos;
 71 |             }
 72 |             else {
 73 |                 // If completion wasn't explicitly started and there
 74 |                 // is no word before the cursor, don't open completions.
 75 |                 return null;
 76 |             }
 77 |         }
 78 |         return {
 79 |             from,
 80 |             options: data,
 81 |             validFor: validFor ? new RegExp(`^${validFor.source}$`)
 82 |                 : undefined,
 83 |         };
 84 |     },
 85 | });
 86 | 
 87 | function muffin() {
 88 |     return new LanguageSupport(muffinLanguage, [muffinCompletion]);
 89 | }
 90 | 
 91 | export function createEditorState(initialContents) {
 92 |     const extensions = [
 93 |         lineNumbers(),
 94 |         highlightActiveLineGutter(),
 95 |         history(),
 96 |         foldGutter(),
 97 |         drawSelection(),
 98 |         indentUnit.of("    "),
 99 |         autocompletion(),
100 |         closeBrackets(),
101 |         EditorState.allowMultipleSelections.of(true),
102 |         rectangularSelection(),
103 |         crosshairCursor(),
104 |         highlightActiveLine(),
105 |         highlightSelectionMatches(),
106 |         keymap.of([
107 |             {
108 |                 key: "Tab",
109 |                 run: acceptCompletion,
110 |             },
111 |             {
112 |                 key: "Mod-f",
113 |                 run: openSearchPanel,
114 |             },
115 |             indentWithTab,
116 |             ...defaultKeymap,
117 |             ...historyKeymap,
118 |             ...foldKeymap,
119 |             ...completionKeymap,
120 |         ]),
121 |         muffin(),
122 |         EditorView.theme({".cm-scroller": {fontFamily: "inherit"}}),
123 |         oneDark,
124 |     ];
125 | 
126 |     return EditorState.create({
127 |         doc: initialContents,
128 |         extensions
129 |     });
130 | }
131 | 
132 | export { EditorView };
133 | 


--------------------------------------------------------------------------------
/src/muffin.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     --body-margin-y: 4px;
  3 |     background-color: black;
  4 |     font-family: Consolas, monaco, monospace;
  5 |     color: white;
  6 |     margin: var(--body-margin-y) 0.75em;
  7 |     padding: 0;
  8 | }
  9 | 
 10 | div#body-wrapper {
 11 |     display: flex;
 12 |     flex-direction: column;
 13 |     height: calc(100vh - 2 * var(--body-margin-y));
 14 | }
 15 | 
 16 | div#demo-body {
 17 |     flex-grow: 1;
 18 |     display: flex;
 19 | }
 20 | 
 21 | div#body-left,
 22 | div#body-right {
 23 |     width: 50%;
 24 |     display: flex;
 25 |     flex-direction: column;
 26 |     padding: 0 0.5em;
 27 | }
 28 | 
 29 | h1#title {
 30 |     font-size: 24px;
 31 |     text-align: center;
 32 |     margin-top: 0.2em;
 33 |     margin-bottom: 0;
 34 | }
 35 | 
 36 | p#description {
 37 |     text-align: center;
 38 |     margin-top: 0.2em;
 39 | }
 40 | 
 41 | div#code-wrapper {
 42 |     position: relative;
 43 |     height: 100%;
 44 | }
 45 | 
 46 | div#code {
 47 |     position: absolute;
 48 |     overflow-y: auto;
 49 |     top: 0;
 50 |     bottom: 0;
 51 |     left: 0;
 52 |     right: 0;
 53 |     border: solid 1px rgb(84, 87, 89);
 54 |     font-size: 14px;
 55 | }
 56 | 
 57 | .cm-editor {
 58 |     height: 100%;
 59 | }
 60 | 
 61 | .cm-search button[name="close"] {
 62 |     color: white;
 63 | }
 64 | 
 65 | div#toolbar {
 66 |     display: flex;
 67 |     gap: 4px;
 68 | }
 69 | 
 70 | button#run,
 71 | button#compile-to-node,
 72 | button#load-example,
 73 | button#open-docs {
 74 |     display: flex;
 75 |     align-items: center;
 76 |     gap: 0.3em;
 77 |     font-family: inherit;
 78 |     font-size: 20px;
 79 |     color: white;
 80 |     border: 1px solid;
 81 |     border-radius: 2px;
 82 |     cursor: pointer;
 83 | }
 84 | 
 85 | button#run svg,
 86 | button#load-example svg {
 87 |     fill: white;
 88 | }
 89 | 
 90 | button#run.can-run {
 91 |     background-color: #008024;
 92 |     border-color: #01b328;
 93 | }
 94 | button#run.can-run:hover {
 95 |     background-color: #019927;
 96 | }
 97 | button#run.can-run svg#stop-icon {
 98 |     display: none;
 99 | }
100 | 
101 | button#run.can-stop {
102 |     background-color: #b30000;
103 |     border-color: #ff0000;
104 | }
105 | button#run.can-stop:hover {
106 |     background-color: #db0000;
107 | }
108 | button#run.can-stop svg#run-icon {
109 |     display: none;
110 | }
111 | 
112 | button#compile-to-node {
113 |     background-color: #1f69d1;
114 |     border-color: #3e8fff;
115 | }
116 | button#compile-to-node:hover {
117 |     background-color: #2580ff;
118 | }
119 | 
120 | button#compile-to-node svg,
121 | button#open-docs svg {
122 |     stroke: white;
123 | }
124 | 
125 | div#example-dropdown {
126 |     display: inline-block;
127 |     position: relative;
128 | }
129 | 
130 | div#examples {
131 |     display: none;
132 |     position: absolute;
133 |     box-shadow: 0px 1px 2px 1px #ffffff66;
134 | }
135 | div#example-dropdown:hover div#examples {
136 |     display: block;
137 |     z-index: 1;
138 | }
139 | 
140 | div#examples span {
141 |     display: block;
142 |     background-color: #282c34;
143 |     color: white;
144 |     cursor: pointer;
145 |     font-size: 14px;
146 |     padding: 0.15em 0.3em;
147 | }
148 | div#examples span:hover {
149 |     background-color: #6bacff;
150 |     color: black;
151 | }
152 | 
153 | button#load-example {
154 |     cursor: auto;
155 |     background-color: #8a00a3;
156 |     border-color: #b623d0;
157 | }
158 | 
159 | button#open-docs {
160 |     background-color: #178ca0;
161 |     border-color: #25b3cb;
162 | }
163 | button#open-docs:hover {
164 |     background-color: #1aaac2;
165 | }
166 | 
167 | div#execution-wrapper {
168 |     position: relative;
169 |     height: 100%;
170 | }
171 | p#execution {
172 |     position: absolute;
173 |     overflow-y: auto;
174 |     top: 0;
175 |     bottom: 0;
176 |     left: 0;
177 |     right: 0;
178 |     background-color: #282c34;
179 |     border: solid 1px rgb(84, 87, 89);
180 |     padding: 0.4em 0.7em;
181 |     font-size: 14px;
182 | }
183 | 
184 | span.exec-error {
185 |     color: #f55663;
186 | }
187 | span.exec-info {
188 |     color: rgb(164, 164, 164);
189 | }
190 | span.exec-normal {
191 |     color: white;
192 | }
193 | span.exec-input {
194 |     color: #6bacff;
195 | }
196 | 
197 | div#input-bar {
198 |     display: flex;
199 |     margin: 0.45em 0;
200 | }
201 | 
202 | input#input-line {
203 |     flex-grow: 1;
204 |     outline: none;
205 |     padding: 0.25em 0.5em;
206 |     font-family: inherit;
207 |     font-size: 14px;
208 |     background-color: #282c34;
209 |     color: white;
210 |     border: 1px solid rgb(84, 87, 89);
211 |     border-radius: 2px 0 0 2px;
212 | }
213 | input#input-line:disabled {
214 |     border-color: #949aa9;
215 |     background-color: #4a515f;
216 |     cursor: not-allowed;
217 | }
218 | input#input-line::placeholder {
219 |     color: #afafaf;
220 | }
221 | 
222 | button#send {
223 |     font-family: inherit;
224 |     font-size: 16px;
225 |     color: white;
226 |     border: 1px solid;
227 |     border-radius: 0 2px 2px 0;
228 | }
229 | button#send:enabled {
230 |     background-color: #ad5700;
231 |     border-color: #ff8000;
232 |     cursor: pointer;
233 | }
234 | button#send:enabled:hover {
235 |     background-color: #d76c00;
236 | }
237 | 
238 | button#send:disabled,
239 | button#compile-to-node:disabled {
240 |     background-color: #808080;
241 |     border-color: #afafaf;
242 |     cursor: not-allowed;
243 | }
244 | 
245 | p {
246 |     margin-top: 0.5em;
247 |     margin-bottom: 0.5em;
248 | }
249 | 
250 | a {
251 |     color: rgb(35, 182, 255);
252 |     /*
253 |         These are usually defined in UA style sheet but links that does
254 |         not actually "link" anywhere (no href) may not have them:
255 |     */
256 |     text-decoration: underline;
257 |     cursor: pointer;
258 | }
259 | a:visited {
260 |     color: rgb(140, 140, 237);
261 | }
262 | a:hover {
263 |     color: rgb(0, 200, 255);
264 | }
265 | 
266 | p.fine-print {
267 |     font-size: 14px;
268 | }
269 | 


--------------------------------------------------------------------------------
/src/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 |     <head>
  4 |         <meta charset="utf-8">
  5 |         <meta name="viewport" content="width=device-width, initial-scale=1">
  6 |         <title>Muffin!</title>
  7 |         <link rel="stylesheet" href="muffin.css">
  8 |         <script defer src="muffin.bundle.min.js"></script>
  9 |     </head>
 10 |     <body>
 11 |         <div id="body-wrapper">
 12 |             <h1 id="title">The Muffin Programming Language</h1>
 13 |             <p id="description" class="fine-print">
 14 |                 A programming language I made that allows you to write programs
 15 |                 that look like cooking recipes. Check out the
 16 |                 <a
 17 |                     href="https://github.com/CBerJun/Muffin"
 18 |                     target="_blank" rel="noreferrer"
 19 |                 >README file</a> for details!
 20 |             </p>
 21 |             <div id="demo-body">
 22 |                 <div id="body-left">
 23 |                     <div id="code-wrapper">
 24 |                         <div id="code"></div>
 25 |                     </div>
 26 |                     <p id="copyright" class="fine-print">
 27 |                         Muffin is completely open-source! Check out the
 28 |                         <a
 29 |                             href="https://github.com/CBerJun/Muffin"
 30 |                             target="_blank" rel="noreferrer"
 31 |                         >repo</a>!
 32 |                         <br>
 33 |                         This wonderful editor is powered by
 34 |                         <a
 35 |                             href="https://codemirror.net/"
 36 |                             target="_blank" rel="noreferrer"
 37 |                         >CodeMirror</a>.
 38 |                     </p>
 39 |                 </div>
 40 |                 <div id="body-right">
 41 |                     <div id="toolbar">
 42 |                         <button
 43 |                             id="run" type="button"
 44 |                             onclick="muffin.onRunButtonClicked()"
 45 |                         >
 46 |                             <span id="run-text"></span>
 47 |                             <svg width="12" height="12" viewBox="0 0 12 12"
 48 |                                 xmlns="http://www.w3.org/2000/svg"
 49 |                                 id="run-icon">
 50 |                                 <path d="M0 0v12l10 -6z"></path>
 51 |                             </svg>
 52 |                             <svg width="12" height="12" viewBox="0 0 12 12"
 53 |                                 xmlns="http://www.w3.org/2000/svg"
 54 |                                 id="stop-icon">
 55 |                                 <path d="M0 0v12h3v-12z M6 0v12h3v-12h-3">
 56 |                                 </path>
 57 |                             </svg>
 58 |                         </button>
 59 |                         <button
 60 |                             id="compile-to-node" type="button"
 61 |                             onclick="muffin.onCompileToNodeButtonClicked()"
 62 |                         >
 63 |                             Compile
 64 |                             <svg width="12" height="12" viewBox="0 0 24 24"
 65 |                                 xmlns="http://www.w3.org/2000/svg"
 66 |                             >
 67 |                                 <polyline points="8,4 1,12 8,20"
 68 |                                     fill="none" stroke-width="3px"></polyline>
 69 |                                 <line x1="15" y1="0" x2="9" y2="24"
 70 |                                     stroke-width="3px"></line>
 71 |                                 <polyline points="16,4 23,12 16,20"
 72 |                                     fill="none" stroke-width="3px"></polyline>
 73 |                             </svg>
 74 |                         </button>
 75 |                         <div id="example-dropdown">
 76 |                             <button id="load-example" type="button">
 77 |                                 Examples
 78 |                                 <svg width="10" height="8" viewBox="2 2 10 8"
 79 |                                     xmlns="http://www.w3.org/2000/svg"
 80 |                                 >
 81 |                                     <path d="M2 2h8l-4 8z"></path>
 82 |                                 </svg>
 83 |                             </button>
 84 |                             <div id="examples"></div>
 85 |                         </div>
 86 |                         <button
 87 |                             id="open-docs" type="button"
 88 |                             onclick="muffin.openDocs()"
 89 |                         >
 90 |                             Docs
 91 |                             <svg width="9" height="12" viewBox="0 0 18 24"
 92 |                                 xmlns="http://www.w3.org/2000/svg"
 93 |                             >
 94 |                                 <polyline points="0,0 10,0 18,8 18,24 0,24 0,0"
 95 |                                     fill="none" stroke-width="3px"></polyline>
 96 |                                 <line x1="3" y1="11" x2="15" y2="11"
 97 |                                     stroke-width="2px"></line>
 98 |                                 <line x1="3" y1="15" x2="15" y2="15"
 99 |                                     stroke-width="2px"></line>
100 |                                 <line x1="3" y1="19" x2="15" y2="19"
101 |                                     stroke-width="2px"></line>
102 |                             </svg>
103 |                         </button>
104 |                     </div>
105 |                     <div id="execution-wrapper">
106 |                         <p id="execution">
107 |                             <span class="exec-info">
108 |                                 Welcome to Muffin's online compiler!
109 |                                 <br>
110 |                                 <br>
111 |                                 Write your code (recipe) using the editor on
112 |                                 the left, and click the Run button to run it!
113 |                                 <br>
114 |                                 A Hello, world! example has been loaded in the
115 |                                 editor.
116 |                             </span>
117 |                         </p>
118 |                     </div>
119 |                     <div id="input-bar">
120 |                         <input id="input-line" type="text"
121 |                             placeholder="Send text to stdin..."
122 |                             autocapitalize="off" autocomplete="off">
123 |                         <button
124 |                             id="send" type="button"
125 |                             onclick="muffin.onSendButtonClicked()"
126 |                         >
127 |                             Send
128 |                         </button>
129 |                     </div>
130 |                 </div>
131 |             </div>
132 |         </div>
133 |     </body>
134 | </html>
135 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # The Muffin Programming Language
  2 | 
  3 | **Muffin** is a brand new **programming language** designed and implemented by
  4 | me in order to participate in [High Seas hold by Hack Club][high-seas].
  5 | 
  6 | Muffin allows you to write programs that look like **cooking recipes**.
  7 | 
  8 | Here is "Hello, world!" in Muffin:
  9 | 
 10 | ```
 11 | Muffin recipe
 12 | ingredients
 13 |     "Hello, world!" brand Flour
 14 | method
 15 |     1. set up a Muffin Cup
 16 |     2. add Flour into Muffin Cup
 17 |     3. microwave Muffin Cup
 18 |     4. serves 1
 19 | ```
 20 | 
 21 | I know this is definitely *not* how you make muffins, but it *is* a program
 22 | that will print out "Hello, world!".
 23 | 
 24 | This program prints out the first 20 Fibonacci numbers:
 25 | 
 26 | ```
 27 | Muffin recipe
 28 | ingredients
 29 |     1 Blueberry
 30 |     19 grams of Butter
 31 | method
 32 |     1. set up 4 Bowls
 33 |     2. add Blueberry into 3rd Bowl
 34 |     3. add water to 1st Bowl at a 1:1 ratio
 35 |     4. pour half of contents of 1st Bowl into 4th Bowl
 36 |     5. remove Butter from 4th Bowl
 37 |     6. if 4th Bowl is not empty, proceed to step 15
 38 |     7. place 3rd Bowl in the oven and bake at 190C
 39 |     8. clean 4th Bowl
 40 |     9. pour contents of 2nd Bowl into 4th Bowl
 41 |     10. add water to 3rd Bowl at a 1:1 ratio
 42 |     11. pour half of contents of 3rd Bowl into 2nd Bowl
 43 |     12. pour contents of 4th Bowl into 3rd Bowl
 44 |     13. add Blueberry into 1st Bowl
 45 |     14. go back to step 3
 46 |     15. serves 1
 47 | ```
 48 | 
 49 | [high-seas]: https://highseas.hackclub.com/
 50 | 
 51 | # Visit Muffin's [demo website][muffin-demo]!
 52 | 
 53 | I built a web page so that you can play around a bit with Muffin! You can run
 54 | Muffin programs in the browser, see more example Muffin programs, and write
 55 | your recipe in an editor with syntax highlighting, autocompletion and other
 56 | features in your favorite IDE! (Thanks to [Cloudflare Pages][cloudflare-pages]
 57 | for hosting this!)
 58 | 
 59 | [muffin-demo]: https://muffinlang.pages.dev/
 60 | [cloudflare-pages]: https://pages.cloudflare.com/
 61 | 
 62 | # Language Specification
 63 | 
 64 | Here are a few important concepts of Muffin:
 65 | 
 66 | * *Recipes* are equivalent to functions/procedures in many programming
 67 |   languages. A recipe is made up of a name, ingredients and a method. The
 68 |   function's name is what this tasty recipe produces (e.g. `Raisin Scone`). The
 69 |   `Muffin` recipe is the entry recipe of the whole program (similar to `main`
 70 |   in C/C++, Java, Go, etc.), i.e. when you execute a Muffin code the `Muffin`
 71 |   recipe will be invoked.
 72 | * *Bowls* are equivalent to variables in many programming languages. The data
 73 |   hold by bowls are always *unsigned integers*, i.e. nonnegative integers.
 74 |   *You can't have -10 grams of butter in a bowl!* A bowl has a
 75 |   *bowl kind* and a *bowl number*. You can declare how many bowls there are
 76 |   for a specific bowl kind, and each bowl can be referred to using their
 77 |   number.
 78 | 
 79 |   For example, if you set up four `Glass Bowls`, then the four bowls can be
 80 |   referred to as `1st Glass Bowl`, `2nd Glass Bowl`, etc. If there is only one
 81 |   bowl of a kind, then just use the bowl kind to refer to that bowl (e.g.
 82 |   `Glass Bowl`).
 83 | 
 84 |   Bowls are "local" to the recipe they are in. That is, two bowls, even if they
 85 |   have the same kind and number, aren't the same if they are in two different
 86 |   recipes.
 87 | * *Ingredients* are used for writing constants in Muffin. The way you write
 88 |   `x + 10` in Muffin is to declare an ingredient with value 10 and "add" that
 89 |   ingredient into a bowl. An ingredient can also take a string value, and in
 90 |   that case you can't add it to a bowl.
 91 | * A *method* is the body of a recipe. It consists of a series of *steps*, which
 92 |   are equivalent to statements in other languages.
 93 | * *Molds* are Muffin's implementation of stack -- it is a list of values, but
 94 |   you only have access to the last element. Similar to how bowls work, molds
 95 |   have a *mold kind* and a *mold number*, and you refer to them using ordinals
 96 |   if there are multiple molds of the same kind.
 97 | 
 98 |   The difference between molds and bowls is that molds may contain both string
 99 |   and unsigned integers (just like ingredients), while bowls can only contain
100 |   unsigned integers. Another difference is that molds are "global". That is,
101 |   all the recipes share the same molds.
102 | 
103 | Regarding the syntax:
104 | 
105 | * All `lowercase phrases` are *keywords*. That means, all these phrases are
106 |   reserved.
107 | * All `Title Case Phrases` are *identifiers* and you may use these names
108 |   freely.
109 | * There is no comment. *Why do you expect a "comment" in a cooking recipe?*
110 | * New lines are significant. However, blank lines are ignored.
111 | * Indentation is not significant.
112 | 
113 | A Muffin program consists of many recipes, separated by new lines.
114 | *I guess you could call a Muffin program a "recipe book".*
115 | 
116 | A recipe takes this form:
117 | 
118 | ```
119 | <Recipe name> recipe
120 | ingredients
121 |     <Ingredient list>
122 | method
123 |     <Step list>
124 | ```
125 | 
126 | `<Recipe name>` should be an identifier (Title Case). That's the name of this
127 | recipe.
128 | 
129 | `<Ingredient list>` is a list of ingredient declarations separated by new
130 | lines. An ingredient declaration takes any of these forms:
131 | 
132 | ```
133 | <String> brand <Ingredient name>
134 | <Integer> <Ingredient name>
135 | <Integer> grams of <Ingredient name>
136 | ```
137 | 
138 | `<Ingredient name>` must be an identifier. `<String>` must be a double quoted
139 | string literal. There is no escape. *What brand name has a double quote in it?*
140 | The first form declares `<Ingredient name>` to be a string `<String>`. The
141 | latter two forms are the same and declare `<Ingredient name>` to be an integer
142 | constant `<Integer>`.
143 | 
144 | `<Step list>` is a list of steps separated by new lines. When a recipe is
145 | executed, the steps in this `<Step list>` will be executed, from the first step
146 | to the last step. A step takes either of these forms:
147 | 
148 | ```
149 | <Label> <Step content>
150 | <Label> if <Predicate>, <Step content>
151 | ```
152 | 
153 | The first form performs the instruction given by `<Step content>`. The second
154 | form performs the given `<Step content>` only if `<Predicate>` evaluates to
155 | true.
156 | 
157 | `<Label>` is an integer with a `.` immediately after it, like `2.`. The first
158 | step in a `<Step list>` must be labelled `1.`, and the second `2.`, the third
159 | `3.`, etc.
160 | 
161 | Before introducing what `<Predicate>` and `<Step content>` look like, here are
162 | a few components that will be used by them (you can go on and read about
163 | `<Step content>` and come back to this later when you encounter a definition
164 | listed here):
165 | 
166 | * A `<Bowl>` specifies a bowl. A bowl has a *bowl kind* and a *bowl number*.
167 |   If there is only one bowl for a given kind of bowl, then the kind identifier
168 |   can be used to refer to that single bowl; otherwise an ordinal like `10th`
169 |   must precede the bowl kind identifier to specify the bowl number. (See above
170 |   for the definition of bowl.)
171 | * A `<Mold>` specifies a mold. The way you specify molds works exactly the same
172 |   way as specifying bowls. (See above for the definition of mold.)
173 | 
174 | `<Step content>` (remember this is similar to a statement in other languages)
175 | takes one of these forms:
176 | 
177 | * `set up a <Bowl kind>` or `set up 1 <Bowl kind>`: Set up one bowl of
178 |   `<Bowl kind>` kind. The same kind may only be set up once in the same recipe.
179 |   This single bowl should be referred to as `<Bowl kind>` in the following
180 |   code. A bowl starts off as an empty bowl. See next rule for the list of
181 |   available `<Bowl kind>`.
182 | * `set up <Integer> <Bowl kind plural>`: Set up `<Integer>` bowls of given
183 |   kind. `<Integer>` must be at least 2. The same kind may only be set up once
184 |   in the same recipe.
185 | 
186 |   Here are all the available bowl kinds:
187 | 
188 |   | `<Bowl kind>`  | `<Bowl kind plural>` |
189 |   | -------------- | -------------------- |
190 |   | `Bowl`         | `Bowls`              |
191 |   | `Glass Bowl`   | `Glass Bowls`        |
192 |   | `Mixing Bowl`  | `Mixing Bowls`       |
193 |   | `Plastic Bowl` | `Plastic Bowls`      |
194 | * `set up a <Mold kind>` or `set up 1 <Mold kind>`: Similar to
195 |   `set up a <Bowl kind>` but create molds instead of bowls. The same mold kind
196 |   may only be set up once in the whole program.
197 | * `set up <Integer> <Mold kind plural>`: Similar to
198 |   `set up <Integer> <Bowl kind plural>` but create molds instead of bowls. The
199 |   same mold kind may only be set up once in the whole program.
200 | 
201 |   Here are all the available mold kinds:
202 | 
203 |   | `<Mold kind>` | `<Mold kind plural>` |
204 |   | ------------- | -------------------- |
205 |   | `Cake Mold`   | `Cake Molds`         |
206 |   | `Muffin Cup`  | `Muffin Cups`        |
207 |   | `Loaf Pan`    | `Loaf Pans`          |
208 |   | `Toast Mold`  | `Toast Molds`        |
209 |   | `Pizza Pan`   | `Pizza Pans`         |
210 |   | `Baking Dish` | `Baking Dishes`      |
211 | * `add <Ingredient name> into <Bowl>`: Add the value of `<Bowl>` by an integer
212 |   constant given by `<Ingredient name>`.
213 | * `remove <Ingredient name> from <Bowl>`: Remove the value of `<Bowl>` by an
214 |   integer constant given by `<Ingredient name>`. If the result is negative, it
215 |   gets cramped to 0 instead. *You can't have -5 oranges in a bowl!*
216 | * `clean <Bowl>`: Set value of `<Bowl>` to 0.
217 | * `add water to <Bowl> at a 1:<Integer> ratio`: Add the value of `<Bowl>` by
218 |   `<Integer>` times of itself. `<Integer>` must be positive. For example,
219 |   a `1:1` ratio doubles the `<Bowl>`.
220 | * `pour half of contents of <Bowl> into <Bowl>`: Transfer half of value of
221 |   first `<Bowl>` into second `<Bowl>`. If first `<Bowl>` is an odd number, then
222 |   "half" always rounds down.
223 | * `pour contents of <Bowl> into <Bowl>`: Transfer all contents of first
224 |   `<Bowl>` into second `<Bowl>`. In other words, second `<Bowl>` gets added the
225 |   value of first `<Bowl>` and the first `<Bowl>` is cleaned.
226 | * `proceed to step <Integer>`: Go to the step labelled `<Integer>`. The
227 |   provided step must be located below the current step textually.
228 | * `go back to step <Integer>`: Go to the step labelled `<Integer>`. The
229 |   provided step must be located above the current step textually.
230 | * `place <Bowl> in the oven and bake at <Temperature>`: This is used to trigger
231 |   a predefined set of built-in functions, according to the `<Temperature>`.
232 |   *Magic oven!*
233 | 
234 |   The `<Temperature>` is a number immediately followed by `C` or `F`.
235 |   *Celsius is better.*
236 | 
237 |   | `<Temperature>` | Best for | Function triggered                          |
238 |   | --------------- | -------- | ------------------------------------------- |
239 |   | `190C`          | Cookie   | Print the integer in `<Bowl>`, then newline |
240 |   | `425F`          | Muffin   | Print the character whose Unicode code point is the integer in `<Bowl>` |
241 |   | `230C`          | Pizza    | Read an integer and store into `<Bowl>`     |
242 |   | `350F`          | Toast    | Read a character and store its Unicode code point into `<Bowl>` |
243 | * `serves <Integer>`: Terminate the recipe. If this is used in the `Muffin`
244 |   recipe, `<Integer> - 1` will be the exit code. So `serves 1` means a normal
245 |   exit.
246 | 
247 |   If the `Muffin` recipe finishes because the last step is done and we didn't
248 |   jump back, then an exit code of 0 (normal exit) is assumed.
249 | * `add <Ingredient name> into <Mold>`: Push the integer or string constant
250 |   specified by `<Ingredient name>` onto `<Mold>`.
251 | * `pour contents of <Bowl> into <Mold>`: Push the value of `<Bowl>` onto
252 |   `<Mold>`, and set value of `<Bowl>` to 0.
253 | * `pour half of contents of <Bowl> into <Mold>`: Push half the value of
254 |   `<Bowl>` onto mold (round down) and `<Bowl>` loses that value.
255 | * `remove a layer from <Mold>`: Remove/Pop the top value from `<Mold>`.
256 | * `remove a layer from <Mold> and dump into <Bowl>`: Remove/Pop the top integer
257 |   value from `<Mold>` and add it into `<Bowl>`.
258 | * `microwave <Mold>`: Print out the top value of `<Mold>` and a new line.
259 | * `microwave <Mold> in grill mode`: Print out the top value of `<Mold>`.
260 | * `stir the mixture in <Mold> until smooth`: Pop the top two integer values of
261 |   `<Mold>` and push a random number, using the top number as maximum and the
262 |   bottom number as minimum (inclusive).
263 | * `sift the mixture in <Mold>`: Pop the top two integer values of `<Mold>` and
264 |   push the result of dividing the bottom value by the top value, with the
265 |   decimal part truncated.
266 | * `whip the mixture in <Mold>`: Pop the top two integer values of `<Mold>` and
267 |   push the result of multiplying them.
268 | * `bring the mixture in <Mold> to a boil`: Pop the top two integer values of
269 |   `<Mold>` and push the result of subtracting the bottom value from the top
270 |   value. If the result is negative, it gets cramped to 0.
271 | * `serve with <Recipe name>`: Execute the recipe named `<Recipe name>` and wait
272 |   until it finishes.
273 | 
274 | For all the commands if an operation is invalid (e.g. adding a string into a
275 | bowl), then a compile time error/runtime error will be thrown and the
276 | compilation/execution stops.
277 | 
278 | `<Predicate>` takes one of these forms:
279 | 
280 | * `<Bowl> is empty`: Test if `<Bowl>` has nothing in it (if it's zero).
281 | * `<Bowl> is not empty`: Opposite of the above.
282 | * `<Mold> is empty`: Test if `<Mold>` has nothing in it (if its size is zero).
283 | * `<Mold> is not empty`: Opposite of the above.
284 | 
285 | # FAQ
286 | 
287 | ## What's the purpose?
288 | 
289 | **Because it's fun!** If you haven't tried before, compilers and programming
290 | languages might be something you will get interested in.
291 | 
292 | Muffin is an *esoteric programming language* (a.k.a. *esolang*). These
293 | languages are not intended for real life projects, but mostly for conducting
294 | research or for fun.
295 | 
296 | You can find a bunch of esolangs on the [esolang wiki][esolang-wiki].
297 | 
298 | [esolang-wiki]: https://esolangs.org/wiki/Main_Page
299 | 
300 | ## Why should I vote for Muffin?
301 | 
302 | Muffin is:
303 | 
304 | * **Technical**: I really designed this programming language and implemented
305 |   it in JavaScript. The compiler works like most compilers in the world --
306 |   tokenizer (lexer), parser, and code generator. The frontend editor is powered
307 |   by [CodeMirror 6](code-mirror). I added the autocompletion, parsing (syntax
308 |   highlighting) and auto-indentation logic. The build script of the frontend is
309 |   written in Python.
310 | * **Creative**: Write tasty programs that look like cooking recipes!
311 | * **Educational**: If you haven't heard of esolangs before, then you've just
312 |   seen one!
313 | * **Presented well**: Muffin has a [demo website][muffin-demo] and you can try
314 |   it out yourself. And look at this descriptive README file!
315 | 
316 | [code-mirror]: https://codemirror.net/
317 | 
318 | ## How do I build your demo website from source locally?
319 | 
320 | Dependencies:
321 | 
322 | * [Node.js](https://nodejs.org/en)
323 | * [Python](https://www.python.org/) 3.6 or above
324 | 
325 | Follow these steps:
326 | 
327 | 1. Run `npm install` under the `src/` directory. This requires network
328 |    connection.
329 | 2. Go back to the project root and use Python to execute the build script
330 |    `build.py`. Depending on your platform, it's either `python build.py` or
331 |    `python3 build.py`.
332 | 3. The website is now ready under `dist/` directory. We just need to serve the
333 |    contents. Using Python, you can do this by `python -m http.server -d dist/`.
334 | 4. Now go to `localhost:8000` in your browser. The website should be there.
335 | 
336 | ## How did you come up with this idea?
337 | 
338 | [Chef][chef] is also a programming language that allows you to write delicious
339 | programs, which has quite different design compared to Muffin. But that
340 | inspired me to create Muffin. The [Fibonacci program in Chef][chef-fibo] took
341 | 34 lines of code, and an additional 6 declaration lines ("ingredients"), while
342 | the same program in Muffin used 17 lines. In that regard, Muffin *might* be a
343 | more concise language.
344 | 
345 | [chef]: https://www.dangermouse.net/esoteric/chef.html
346 | [chef-fibo]: https://www.dangermouse.net/esoteric/chef_fib.html
347 | 


--------------------------------------------------------------------------------
/src/frontend.js:
--------------------------------------------------------------------------------
  1 | import * as cm6 from "./editor.js";
  2 | import { compile, CompileError, CodeGenConfig, NodeConfig } from "./muffin.js";
  3 | 
  4 | const AsyncFunction = async function () {}.constructor;
  5 | 
  6 | const helloWorldCode = `Muffin recipe
  7 | ingredients
  8 |     "Hello, world!" brand Flour
  9 | method
 10 |     1. set up a Muffin Cup
 11 |     2. add Flour into Muffin Cup
 12 |     3. microwave Muffin Cup
 13 |     4. serves 1
 14 | `;
 15 | const editor = new cm6.EditorView({
 16 |     parent: document.getElementById('code'),
 17 |     state: cm6.createEditorState(helloWorldCode),
 18 | });
 19 | 
 20 | function createSubmitIssue() {
 21 |     const submitIssue = document.createElement("a");
 22 |     submitIssue.textContent = "submit an issue";
 23 |     submitIssue.href = "https://github.com/CBerJun/Muffin/issues/new";
 24 |     submitIssue.target = "_blank";
 25 |     submitIssue.rel = "noreferrer";
 26 |     return submitIssue;
 27 | }
 28 | 
 29 | function crashed() {
 30 |     return [
 31 |         "Whoops! The compiler just CRASHED.",
 32 |         document.createElement("br"),
 33 |         "Please return it to the vendor (",
 34 |         createSubmitIssue(),
 35 |         "). Please also tell us the recipe you were trying to use. Thanks!",
 36 |     ];
 37 | }
 38 | 
 39 | const executionBox = document.getElementById("execution");
 40 | const runButton = document.getElementById("run");
 41 | const runButtonText = document.getElementById("run-text");
 42 | const compileToNodeButton = document.getElementById("compile-to-node");
 43 | 
 44 | function executionFinished() {
 45 |     updateRunButtonState("can-run");
 46 |     compileToNodeButton.removeAttribute("disabled");
 47 | }
 48 | 
 49 | function muffinExit(code) {
 50 |     /* Exit handler passed to Muffin compiler. */
 51 |     const element = document.createElement("span");
 52 |     element.className = "exec-info";
 53 |     element.textContent = `Program exited with code ${code}`;
 54 |     executionBox.append(element);
 55 |     executionFinished();
 56 | }
 57 | 
 58 | function muffinError(message) {
 59 |     /* Error handler passed to Muffin compiler. */
 60 |     const element = document.createElement("span");
 61 |     element.className = "exec-error";
 62 |     element.textContent = `Runtime error: ${message}`;
 63 |     executionBox.append(element);
 64 |     executionFinished();
 65 | }
 66 | 
 67 | function muffinUnexpectedError(exc) {
 68 |     /* Unexpected error handler passed to Muffin compiler. */
 69 |     const element = document.createElement("span");
 70 |     let textKind;
 71 |     if (exc instanceof ExecutionCancelled) {
 72 |         textKind = "exec-info";
 73 |         element.textContent = "Execution terminated";
 74 |     }
 75 |     else {
 76 |         // Real unexpected error
 77 |         textKind = "exec-error";
 78 |         console.error(exc);
 79 |         element.append(
 80 |             "An unexpected error occurred when running your recipe.",
 81 |             document.createElement("br"),
 82 |             "It might be due to call stack overflow, in which case you "
 83 |             + "need to check if there are infinite recursions in your recipe. "
 84 |             + "Otherwise, you might have found a bug in Muffin! Please ",
 85 |             createSubmitIssue(),
 86 |             ".",
 87 |             document.createElement("br"),
 88 |             document.createElement("br"),
 89 |             String(exc),
 90 |         );
 91 |     }
 92 |     element.className = textKind;
 93 |     executionBox.append(element);
 94 |     executionFinished();
 95 | }
 96 | 
 97 | function muffinPrint(object) {
 98 |     /* Print/println handler passed to Muffin compiler. */
 99 |     const lines = String(object).split("\n");
100 |     const children = [];
101 |     for (let i = 0; i < lines.length; ++i) {
102 |         children.push(lines[i]);
103 |         if (i < lines.length - 1) {
104 |             children.push(document.createElement("br"));
105 |         }
106 |     }
107 |     const element = document.createElement("span");
108 |     element.className = "exec-normal";
109 |     element.append(...children);
110 |     executionBox.append(element);
111 | }
112 | 
113 | // Boolean indicating if the user has requested to stop the execution:
114 | let executionCanceling;
115 | 
116 | class ExecutionCancelled {}
117 | 
118 | async function muffinRest(opCounter) {
119 |     // If the user requested for stop, throw
120 |     if (executionCanceling) {
121 |         throw new ExecutionCancelled();
122 |     }
123 |     // After 1000 Muffin instructions have been executed, sleep for
124 |     // 10 milliseconds to prevent blocking the whole interpreter.
125 |     if (opCounter >= 999) {
126 |         await new Promise((r) => setTimeout(r, 10));
127 |         return 0;
128 |     }
129 |     return opCounter + 1;
130 | }
131 | 
132 | let readlineResolve = null;
133 | 
134 | async function muffinReadline() {
135 |     const s = await new Promise((r) => {
136 |         readlineResolve = r;
137 |         updateStdinSenderState(true);
138 |         inputLine.focus();
139 |     });
140 |     readlineResolve = null;
141 |     updateStdinSenderState(false);
142 |     // When result `s` is string, that's the input line; or when it is
143 |     // null, that means user stops the execution.
144 |     if (s == null) {
145 |         throw new ExecutionCancelled();
146 |     }
147 |     return s;
148 | }
149 | 
150 | const argError = "T1";
151 | const argExit = "T2";
152 | const argPrint = "T3";
153 | const opCounter = "T4";
154 | const argRest = "T5";
155 | const argReadline = "T6";
156 | const argUnexpectedError = "T7";
157 | 
158 | class MuffinConfig extends CodeGenConfig {
159 |     constructor(owner) {
160 |         super(owner);
161 |         this.asynchronous = true;
162 |         this.loop_epilog = `${opCounter} = await ${argRest}(${opCounter});`;
163 |     }
164 |     handle_error(error) {
165 |         return `${argError}(${error});`;
166 |     }
167 |     handle_unexpected_error(error) {
168 |         return `${argUnexpectedError}(${error});`;
169 |     }
170 |     handle_exit(code) {
171 |         return `${argExit}(${code});`;
172 |     }
173 |     handle_println(object) {
174 |         return `${argPrint}(${object}+"\\n");`;
175 |     }
176 |     handle_print(object) {
177 |         return `${argPrint}(${object});`;
178 |     }
179 |     handle_read_line() {
180 |         return `await ${argReadline}()`;
181 |     }
182 |     at_last(code) {
183 |         return `let ${opCounter} = 0;` + code;
184 |     }
185 | }
186 | 
187 | function updateRunButtonState(state) {
188 |     runButton.className = state;
189 |     runButtonText.textContent = state == "can-run" ? "Run" : "Stop";
190 | }
191 | 
192 | // Initial state:
193 | updateRunButtonState("can-run");
194 | 
195 | function compileCode(configCls) {
196 |     while (executionBox.lastChild) {
197 |         executionBox.lastChild.remove();
198 |     }
199 |     const source = editor.state.doc.toString();
200 |     let jsCode;
201 |     try {
202 |         jsCode = compile(source, configCls);
203 |     }
204 |     catch (exc) {
205 |         const element = document.createElement("span");
206 |         element.className = "exec-error";
207 |         if (exc instanceof CompileError) {
208 |             const prefixes = [];
209 |             if (exc.loc) {
210 |                 const locElement = document.createElement("a");
211 |                 const {line_no, col_no, char_index} = exc.loc;
212 |                 locElement.onclick = (event) => {
213 |                     try {
214 |                         // The index may have become invalid (after
215 |                         // user changes code)
216 |                         editor.dispatch({
217 |                             selection: {anchor: char_index}
218 |                         });
219 |                     }
220 |                     catch (exc) {
221 |                         if (!(exc instanceof RangeError)) {
222 |                             throw exc;
223 |                         }
224 |                     }
225 |                     editor.focus();
226 |                     return false;
227 |                 };
228 |                 locElement.textContent = `line ${line_no} col ${col_no}`;
229 |                 prefixes.push(
230 |                     "At ",
231 |                     locElement,
232 |                     ": ",
233 |                 );
234 |             }
235 |             else {
236 |                 prefixes.push("Cause: ");
237 |             }
238 |             element.append(
239 |                 "Oops... Compilation failed!",
240 |                 document.createElement("br"),
241 |                 ...prefixes,
242 |                 exc.message,
243 |                 document.createElement("br"),
244 |                 "Fix your recipe and try baking it again later.",
245 |             );
246 |         }
247 |         else {
248 |             console.error(exc);
249 |             element.append(...crashed());
250 |         }
251 |         executionBox.appendChild(element);
252 |         return null;
253 |     }
254 |     return jsCode;
255 | }
256 | 
257 | export function onRunButtonClicked() {
258 |     /* Callback from button#run. */
259 |     if (runButton.className == "can-run") {
260 |         const jsCode = compileCode(MuffinConfig);
261 |         if (jsCode == null) {
262 |             return;
263 |         }
264 |         let compiledFunc;
265 |         try {
266 |             compiledFunc = new AsyncFunction(
267 |                 argError, argExit, argPrint, argRest, argReadline,
268 |                 argUnexpectedError,
269 |                 jsCode
270 |             );
271 |         }
272 |         catch (exc) {
273 |             console.error(exc);
274 |             const element = document.createElement("span");
275 |             element.className = "exec-error";
276 |             element.append(...crashed());
277 |             return;
278 |         }
279 |         updateRunButtonState("can-stop");
280 |         compileToNodeButton.setAttribute("disabled", "");
281 |         executionCanceling = false;
282 |         compiledFunc(
283 |             muffinError, muffinExit, muffinPrint, muffinRest, muffinReadline,
284 |             muffinUnexpectedError
285 |         );
286 |     }
287 |     else {
288 |         executionCanceling = true;
289 |         if (readlineResolve != null) {
290 |             readlineResolve(null);
291 |         }
292 |     }
293 | }
294 | 
295 | const sendButton = document.getElementById("send");
296 | const inputLine = document.getElementById("input-line");
297 | 
298 | function updateStdinSenderState(enabled) {
299 |     if (enabled) {
300 |         sendButton.removeAttribute("disabled");
301 |         inputLine.removeAttribute("disabled");
302 |     }
303 |     else {
304 |         sendButton.setAttribute("disabled", "");
305 |         inputLine.setAttribute("disabled", "");
306 |     }
307 | }
308 | 
309 | // Initial state:
310 | updateStdinSenderState(false);
311 | 
312 | export function onSendButtonClicked() {
313 |     if (readlineResolve == null) {
314 |         console.error("should have readlineResolve non-null");
315 |     }
316 |     else {
317 |         const s = inputLine.value;
318 |         inputLine.value = "";
319 |         readlineResolve(s);
320 |         const element = document.createElement("span");
321 |         element.className = "exec-input";
322 |         element.textContent = s;
323 |         executionBox.append(
324 |             element,
325 |             document.createElement("br"),
326 |         );
327 |     }
328 | }
329 | 
330 | // Allow using Enter key to send
331 | inputLine.addEventListener("keydown", (event) => {
332 |     if (event.key == "Enter") {
333 |         onSendButtonClicked();
334 |     }
335 | });
336 | 
337 | export function onCompileToNodeButtonClicked() {
338 |     const jsCode = compileCode(NodeConfig);
339 |     if (jsCode == null) {
340 |         return;
341 |     }
342 |     const hintElement = document.createElement("span");
343 |     hintElement.className = "exec-info";
344 |     hintElement.textContent = (
345 |         "Muffin compiles down to JavaScript. Here's the compiled code for "
346 |         + "your recipe, which needs to run in a Node.js environment."
347 |     );
348 |     const codeElement = document.createElement("span");
349 |     codeElement.className = "exec-normal";
350 |     codeElement.textContent = jsCode;
351 |     executionBox.append(
352 |         hintElement,
353 |         document.createElement("br"),
354 |         document.createElement("br"),
355 |         codeElement,
356 |     );
357 | }
358 | 
359 | const examples = new Map([
360 |     ["Hello, world!", helloWorldCode],
361 |     ["Fibonacci", `Muffin recipe
362 | ingredients
363 |     1 Blueberry
364 |     19 grams of Butter
365 | method
366 |     1. set up 4 Bowls
367 |     2. add Blueberry into 3rd Bowl
368 |     3. add water to 1st Bowl at a 1:1 ratio
369 |     4. pour half of contents of 1st Bowl into 4th Bowl
370 |     5. remove Butter from 4th Bowl
371 |     6. if 4th Bowl is not empty, proceed to step 15
372 |     7. place 3rd Bowl in the oven and bake at 190C
373 |     8. clean 4th Bowl
374 |     9. pour contents of 2nd Bowl into 4th Bowl
375 |     10. add water to 3rd Bowl at a 1:1 ratio
376 |     11. pour half of contents of 3rd Bowl into 2nd Bowl
377 |     12. pour contents of 4th Bowl into 3rd Bowl
378 |     13. add Blueberry into 1st Bowl
379 |     14. go back to step 3
380 |     15. serves 1
381 | `],
382 |     ["FizzBuzz", `Muffin recipe
383 | ingredients
384 |     100 grams of Sugar
385 |     1 Egg
386 |     3 grams of Salt
387 |     5 grams of Maple Syrup
388 |     "Fizz" brand Whipping Cream
389 |     "Buzz" brand Vanilla Beans
390 |     "FizzBuzz" brand Sour Cream
391 | method
392 |     1. set up 2 Bowls
393 |     2. set up a Pizza Pan
394 |     3. add Egg into 1st Bowl
395 |     4. add water to 1st Bowl at a 1:1 ratio
396 |     5. clean 2nd Bowl
397 |     6. pour half of contents of 1st Bowl into 2nd Bowl
398 |     7. remove Sugar from 2nd Bowl
399 |     8. if 2nd Bowl is not empty, proceed to step 34
400 |     9. add water to 1st Bowl at a 1:1 ratio
401 |     10. pour half of contents of 1st Bowl into Pizza Pan
402 |     11. add Salt into Pizza Pan
403 |     12. serve with Blueberry Sauce
404 |     13. add water to 1st Bowl at a 1:1 ratio
405 |     14. pour half of contents of 1st Bowl into Pizza Pan
406 |     15. add Maple Syrup into Pizza Pan
407 |     16. serve with Blueberry Sauce
408 |     17. remove a layer from Pizza Pan and dump into 2nd Bowl
409 |     18. if 2nd Bowl is empty, proceed to step 24
410 |     19. clean 2nd Bowl
411 |     20. remove a layer from Pizza Pan and dump into 2nd Bowl
412 |     21. if 2nd Bowl is empty, proceed to step 28
413 |     22. place 1st Bowl in the oven and bake at 190C
414 |     23. proceed to step 33
415 |     24. remove a layer from Pizza Pan and dump into 2nd Bowl
416 |     25. if 2nd Bowl is empty, proceed to step 30
417 |     26. add Vanilla Beans into Pizza Pan
418 |     27. proceed to step 31
419 |     28. add Whipping Cream into Pizza Pan
420 |     29. proceed to step 31
421 |     30. add Sour Cream into Pizza Pan
422 |     31. microwave Pizza Pan
423 |     32. remove a layer from Pizza Pan
424 |     33. go back to step 3
425 |     34. serves 1
426 | 
427 | Blueberry Sauce recipe
428 | ingredients
429 | method
430 |     1. set up 2 Bowls
431 |     2. remove a layer from Pizza Pan and dump into 2nd Bowl
432 |     3. remove a layer from Pizza Pan and dump into 1st Bowl
433 |     4. add water to 1st Bowl at a 1:1 ratio
434 |     5. pour half of contents of 1st Bowl into Pizza Pan
435 |     6. pour contents of 1st Bowl into Pizza Pan
436 |     7. add water to 2nd Bowl at a 1:1 ratio
437 |     8. pour half of contents of 2nd Bowl into Pizza Pan
438 |     9. sift the mixture in Pizza Pan
439 |     10. pour contents of 2nd Bowl into Pizza Pan
440 |     11. whip the mixture in Pizza Pan
441 |     12. bring the mixture in Pizza Pan to a boil
442 | `],
443 |     ["Guess the Number", `Muffin recipe
444 | ingredients
445 |     1 Onion
446 |     100 grams of Sugar
447 |     "Guess a number between " brand Cheddar Cheese
448 |     " and " brand Mozzarella Cheese
449 |     "Make a guess: " brand Chives
450 |     "Too big" brand Sausages
451 |     "Too small" brand Shallots
452 |     "Correct!" brand Butter
453 | method
454 |     1. set up a Toast Mold
455 |     2. set up 3 Bowls
456 |     3. add Cheddar Cheese into Toast Mold
457 |     4. microwave Toast Mold in grill mode
458 |     5. remove a layer from Toast Mold
459 |     6. add Onion into Toast Mold
460 |     7. microwave Toast Mold in grill mode
461 |     8. add Mozzarella Cheese into Toast Mold
462 |     9. microwave Toast Mold in grill mode
463 |     10. remove a layer from Toast Mold
464 |     11. add Sugar into Toast Mold
465 |     12. microwave Toast Mold
466 |     13. stir the mixture in Toast Mold until smooth
467 |     14. remove a layer from Toast Mold and dump into 1st Bowl
468 |     15. add Chives into Toast Mold
469 |     16. microwave Toast Mold in grill mode
470 |     17. remove a layer from Toast Mold
471 |     18. place 2nd Bowl in the oven and bake at 230C
472 |     19. add water to 2nd Bowl at a 1:1 ratio
473 |     20. pour half of contents of 2nd Bowl into Toast Mold
474 |     21. add water to 1st Bowl at a 1:1 ratio
475 |     22. pour half of contents of 1st Bowl into Toast Mold
476 |     23. bring the mixture in Toast Mold to a boil
477 |     24. clean 3rd Bowl
478 |     25. remove a layer from Toast Mold and dump into 3rd Bowl
479 |     26. add water to 1st Bowl at a 1:1 ratio
480 |     27. pour half of contents of 1st Bowl into Toast Mold
481 |     28. pour contents of 2nd Bowl into Toast Mold
482 |     29. bring the mixture in Toast Mold to a boil
483 |     30. remove a layer from Toast Mold and dump into 2nd Bowl
484 |     31. if 3rd Bowl is empty, proceed to step 34
485 |     32. add Sausages into Toast Mold
486 |     33. proceed to step 36
487 |     34. if 2nd Bowl is empty, proceed to step 39
488 |     35. add Shallots into Toast Mold
489 |     36. microwave Toast Mold
490 |     37. remove a layer from Toast Mold
491 |     38. go back to step 15
492 |     39. add Butter into Toast Mold
493 |     40. microwave Toast Mold
494 | `],
495 |     ["99 Bottles of Beer", `Muffin recipe
496 | ingredients
497 |     " of beer on the wall, " brand Beer
498 |     " of beer." brand Ginger Ale
499 |     "Take one down and pass it around, " brand Yogurt
500 |     " of beer on the wall." brand Basil
501 |     1 Egg Yolk
502 |     99 Eggs
503 | method
504 |     1. set up a Pizza Pan
505 |     2. set up a Bowl
506 |     3. add Eggs into Bowl
507 |     4. add water to Bowl at a 1:1 ratio
508 |     5. pour half of contents of Bowl into Pizza Pan
509 |     6. serve with Fruit Salad
510 |     7. add Beer into Pizza Pan
511 |     8. microwave Pizza Pan in grill mode
512 |     9. remove a layer from Pizza Pan
513 |     10. add water to Bowl at a 1:1 ratio
514 |     11. pour half of contents of Bowl into Pizza Pan
515 |     12. serve with Fruit Salad
516 |     13. add Ginger Ale into Pizza Pan
517 |     14. microwave Pizza Pan
518 |     15. remove a layer from Pizza Pan
519 |     16. add Yogurt into Pizza Pan
520 |     17. microwave Pizza Pan in grill mode
521 |     18. remove a layer from Pizza Pan
522 |     19. remove Egg Yolk from Bowl
523 |     20. add water to Bowl at a 1:1 ratio
524 |     21. pour half of contents of Bowl into Pizza Pan
525 |     22. serve with Fruit Salad
526 |     23. add Basil into Pizza Pan
527 |     24. microwave Pizza Pan
528 |     25. remove a layer from Pizza Pan
529 |     26. if Bowl is not empty, go back to step 4
530 | 
531 | Fruit Salad recipe
532 | ingredients
533 |     " bottles" brand Star Fruit
534 |     "1 bottle" brand Coconuts
535 |     "no more bottles" brand Strawberries
536 |     1 Egg
537 | method
538 |     1. set up a Bowl
539 |     2. remove a layer from Pizza Pan and dump into Bowl
540 |     3. if Bowl is empty, proceed to step 12
541 |     4. remove Egg from Bowl
542 |     5. if Bowl is empty, proceed to step 14
543 |     6. add Egg into Bowl
544 |     7. pour contents of Bowl into Pizza Pan
545 |     8. microwave Pizza Pan in grill mode
546 |     9. remove a layer from Pizza Pan
547 |     10. add Star Fruit into Pizza Pan
548 |     11. proceed to step 15
549 |     12. add Strawberries into Pizza Pan
550 |     13. proceed to step 15
551 |     14. add Coconuts into Pizza Pan
552 |     15. microwave Pizza Pan in grill mode
553 |     16. remove a layer from Pizza Pan
554 | `],
555 |     ["Factorial", `Muffin recipe
556 | ingredients
557 |     1 Potato
558 |     "Enter a nonnegative integer: " brand Oregano
559 |     "! = " brand Cheese
560 | method
561 |     1. set up a Baking Dish
562 |     2. set up a Bowl
563 |     3. add Oregano into Baking Dish
564 |     4. microwave Baking Dish in grill mode
565 |     5. place Bowl in the oven and bake at 230C
566 |     6. add water to Bowl at a 1:1 ratio
567 |     7. pour half of contents of Bowl into Baking Dish
568 |     8. add Potato into Baking Dish
569 |     9. if Bowl is empty, proceed to step 15
570 |     10. add water to Bowl at a 1:1 ratio
571 |     11. pour half of contents of Bowl into Baking Dish
572 |     12. whip the mixture in Baking Dish
573 |     13. remove Potato from Bowl
574 |     14. go back to step 9
575 |     15. remove a layer from Baking Dish and dump into Bowl
576 |     16. microwave Baking Dish in grill mode
577 |     17. add Cheese into Baking Dish
578 |     18. microwave Baking Dish in grill mode
579 |     19. place Bowl in the oven and bake at 190C
580 | `],
581 |     ["Input/Output", `Muffin recipe
582 | ingredients
583 |     "Enter an integer: " brand Flour
584 |     "Enter a character: " brand Butter
585 |     "You typed " brand Eggs
586 |     "The code point of your character is " brand Sugar
587 | method
588 |     1. set up 2 Bowls
589 |     2. set up a Pizza Pan
590 |     3. add Flour into Pizza Pan
591 |     4. microwave Pizza Pan in grill mode
592 |     5. place 1st Bowl in the oven and bake at 230C
593 |     6. add Eggs into Pizza Pan
594 |     7. microwave Pizza Pan in grill mode
595 |     8. place 1st Bowl in the oven and bake at 190C
596 |     9. add Butter into Pizza Pan
597 |     10. microwave Pizza Pan in grill mode
598 |     11. place 2nd Bowl in the oven and bake at 350F
599 |     12. add Sugar into Pizza Pan
600 |     13. microwave Pizza Pan in grill mode
601 |     14. place 2nd Bowl in the oven and bake at 190C
602 |     15. serves 1
603 | `],
604 |     ["Infinite Loop", `Muffin recipe
605 | ingredients
606 | method
607 |     1. proceed to step 2
608 |     2. go back to step 1
609 | `],
610 | ]);
611 | 
612 | const examplesDiv = document.getElementById("examples");
613 | 
614 | // Initialize div#examples
615 | examples.forEach((value, key) => {
616 |     const element = document.createElement("span");
617 |     element.textContent = key;
618 |     element.addEventListener("click", () => {
619 |         editor.dispatch({
620 |             changes: {
621 |                 from: 0, to: editor.state.doc.length,
622 |                 insert: value
623 |             }
624 |         });
625 |     });
626 |     examplesDiv.append(element);
627 | });
628 | 
629 | const docsUrl =
630 | "https://github.com/CBerJun/Muffin?tab=readme-ov-file#language-specification";
631 | 
632 | export function openDocs() {
633 |     window.open(docsUrl, "_blank", "noreferrer");
634 | }
635 | 


--------------------------------------------------------------------------------
/src/package-lock.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "name": "codemirror",
  3 |     "lockfileVersion": 3,
  4 |     "requires": true,
  5 |     "packages": {
  6 |         "": {
  7 |             "dependencies": {
  8 |                 "@codemirror/autocomplete": "^6.18.3",
  9 |                 "@codemirror/commands": "^6.1.2",
 10 |                 "@codemirror/search": "^6.2.3",
 11 |                 "@codemirror/theme-one-dark": "^6.1.0",
 12 |                 "@codemirror/view": "^6.6.0",
 13 |                 "@lezer/common": "^1.2.3",
 14 |                 "@lezer/generator": "^1.7.1",
 15 |                 "@lezer/highlight": "^1.2.1",
 16 |                 "@lezer/lr": "^1.4.2",
 17 |                 "@rollup/plugin-node-resolve": "^15.0.1",
 18 |                 "minify": "^9.1.0",
 19 |                 "rollup": "^3.5.1"
 20 |             }
 21 |         },
 22 |         "node_modules/@codemirror/autocomplete": {
 23 |             "version": "6.18.3",
 24 |             "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.18.3.tgz",
 25 |             "integrity": "sha512-1dNIOmiM0z4BIBwxmxEfA1yoxh1MF/6KPBbh20a5vphGV0ictKlgQsbJs6D6SkR6iJpGbpwRsa6PFMNlg9T9pQ==",
 26 |             "license": "MIT",
 27 |             "dependencies": {
 28 |                 "@codemirror/language": "^6.0.0",
 29 |                 "@codemirror/state": "^6.0.0",
 30 |                 "@codemirror/view": "^6.17.0",
 31 |                 "@lezer/common": "^1.0.0"
 32 |             },
 33 |             "peerDependencies": {
 34 |                 "@codemirror/language": "^6.0.0",
 35 |                 "@codemirror/state": "^6.0.0",
 36 |                 "@codemirror/view": "^6.0.0",
 37 |                 "@lezer/common": "^1.0.0"
 38 |             }
 39 |         },
 40 |         "node_modules/@codemirror/commands": {
 41 |             "version": "6.7.1",
 42 |             "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.7.1.tgz",
 43 |             "integrity": "sha512-llTrboQYw5H4THfhN4U3qCnSZ1SOJ60ohhz+SzU0ADGtwlc533DtklQP0vSFaQuCPDn3BPpOd1GbbnUtwNjsrw==",
 44 |             "license": "MIT",
 45 |             "dependencies": {
 46 |                 "@codemirror/language": "^6.0.0",
 47 |                 "@codemirror/state": "^6.4.0",
 48 |                 "@codemirror/view": "^6.27.0",
 49 |                 "@lezer/common": "^1.1.0"
 50 |             }
 51 |         },
 52 |         "node_modules/@codemirror/language": {
 53 |             "version": "6.10.6",
 54 |             "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.10.6.tgz",
 55 |             "integrity": "sha512-KrsbdCnxEztLVbB5PycWXFxas4EOyk/fPAfruSOnDDppevQgid2XZ+KbJ9u+fDikP/e7MW7HPBTvTb8JlZK9vA==",
 56 |             "license": "MIT",
 57 |             "dependencies": {
 58 |                 "@codemirror/state": "^6.0.0",
 59 |                 "@codemirror/view": "^6.23.0",
 60 |                 "@lezer/common": "^1.1.0",
 61 |                 "@lezer/highlight": "^1.0.0",
 62 |                 "@lezer/lr": "^1.0.0",
 63 |                 "style-mod": "^4.0.0"
 64 |             }
 65 |         },
 66 |         "node_modules/@codemirror/search": {
 67 |             "version": "6.5.8",
 68 |             "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.5.8.tgz",
 69 |             "integrity": "sha512-PoWtZvo7c1XFeZWmmyaOp2G0XVbOnm+fJzvghqGAktBW3cufwJUWvSCcNG0ppXiBEM05mZu6RhMtXPv2hpllig==",
 70 |             "license": "MIT",
 71 |             "dependencies": {
 72 |                 "@codemirror/state": "^6.0.0",
 73 |                 "@codemirror/view": "^6.0.0",
 74 |                 "crelt": "^1.0.5"
 75 |             }
 76 |         },
 77 |         "node_modules/@codemirror/state": {
 78 |             "version": "6.4.1",
 79 |             "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.4.1.tgz",
 80 |             "integrity": "sha512-QkEyUiLhsJoZkbumGZlswmAhA7CBU02Wrz7zvH4SrcifbsqwlXShVXg65f3v/ts57W3dqyamEriMhij1Z3Zz4A==",
 81 |             "license": "MIT"
 82 |         },
 83 |         "node_modules/@codemirror/theme-one-dark": {
 84 |             "version": "6.1.2",
 85 |             "resolved": "https://registry.npmjs.org/@codemirror/theme-one-dark/-/theme-one-dark-6.1.2.tgz",
 86 |             "integrity": "sha512-F+sH0X16j/qFLMAfbciKTxVOwkdAS336b7AXTKOZhy8BR3eH/RelsnLgLFINrpST63mmN2OuwUt0W2ndUgYwUA==",
 87 |             "license": "MIT",
 88 |             "dependencies": {
 89 |                 "@codemirror/language": "^6.0.0",
 90 |                 "@codemirror/state": "^6.0.0",
 91 |                 "@codemirror/view": "^6.0.0",
 92 |                 "@lezer/highlight": "^1.0.0"
 93 |             }
 94 |         },
 95 |         "node_modules/@codemirror/view": {
 96 |             "version": "6.35.0",
 97 |             "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.35.0.tgz",
 98 |             "integrity": "sha512-I0tYy63q5XkaWsJ8QRv5h6ves7kvtrBWjBcnf/bzohFJQc5c14a1AQRdE8QpPF9eMp5Mq2FMm59TCj1gDfE7kw==",
 99 |             "license": "MIT",
100 |             "dependencies": {
101 |                 "@codemirror/state": "^6.4.0",
102 |                 "style-mod": "^4.1.0",
103 |                 "w3c-keyname": "^2.2.4"
104 |             }
105 |         },
106 |         "node_modules/@jridgewell/gen-mapping": {
107 |             "version": "0.3.5",
108 |             "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
109 |             "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
110 |             "license": "MIT",
111 |             "dependencies": {
112 |                 "@jridgewell/set-array": "^1.2.1",
113 |                 "@jridgewell/sourcemap-codec": "^1.4.10",
114 |                 "@jridgewell/trace-mapping": "^0.3.24"
115 |             },
116 |             "engines": {
117 |                 "node": ">=6.0.0"
118 |             }
119 |         },
120 |         "node_modules/@jridgewell/resolve-uri": {
121 |             "version": "3.1.2",
122 |             "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
123 |             "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
124 |             "license": "MIT",
125 |             "engines": {
126 |                 "node": ">=6.0.0"
127 |             }
128 |         },
129 |         "node_modules/@jridgewell/set-array": {
130 |             "version": "1.2.1",
131 |             "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
132 |             "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
133 |             "license": "MIT",
134 |             "engines": {
135 |                 "node": ">=6.0.0"
136 |             }
137 |         },
138 |         "node_modules/@jridgewell/source-map": {
139 |             "version": "0.3.6",
140 |             "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
141 |             "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
142 |             "license": "MIT",
143 |             "dependencies": {
144 |                 "@jridgewell/gen-mapping": "^0.3.5",
145 |                 "@jridgewell/trace-mapping": "^0.3.25"
146 |             }
147 |         },
148 |         "node_modules/@jridgewell/sourcemap-codec": {
149 |             "version": "1.5.0",
150 |             "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
151 |             "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
152 |             "license": "MIT"
153 |         },
154 |         "node_modules/@jridgewell/trace-mapping": {
155 |             "version": "0.3.25",
156 |             "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
157 |             "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
158 |             "license": "MIT",
159 |             "dependencies": {
160 |                 "@jridgewell/resolve-uri": "^3.1.0",
161 |                 "@jridgewell/sourcemap-codec": "^1.4.14"
162 |             }
163 |         },
164 |         "node_modules/@lezer/common": {
165 |             "version": "1.2.3",
166 |             "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.2.3.tgz",
167 |             "integrity": "sha512-w7ojc8ejBqr2REPsWxJjrMFsA/ysDCFICn8zEOR9mrqzOu2amhITYuLD8ag6XZf0CFXDrhKqw7+tW8cX66NaDA==",
168 |             "license": "MIT"
169 |         },
170 |         "node_modules/@lezer/generator": {
171 |             "version": "1.7.1",
172 |             "resolved": "https://registry.npmjs.org/@lezer/generator/-/generator-1.7.1.tgz",
173 |             "integrity": "sha512-MgPJN9Si+ccxzXl3OAmCeZuUKw4XiPl4y664FX/hnnyG9CTqUPq65N3/VGPA2jD23D7QgMTtNqflta+cPN+5mQ==",
174 |             "license": "MIT",
175 |             "dependencies": {
176 |                 "@lezer/common": "^1.1.0",
177 |                 "@lezer/lr": "^1.3.0"
178 |             },
179 |             "bin": {
180 |                 "lezer-generator": "src/lezer-generator.cjs"
181 |             }
182 |         },
183 |         "node_modules/@lezer/highlight": {
184 |             "version": "1.2.1",
185 |             "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.1.tgz",
186 |             "integrity": "sha512-Z5duk4RN/3zuVO7Jq0pGLJ3qynpxUVsh7IbUbGj88+uV2ApSAn6kWg2au3iJb+0Zi7kKtqffIESgNcRXWZWmSA==",
187 |             "license": "MIT",
188 |             "dependencies": {
189 |                 "@lezer/common": "^1.0.0"
190 |             }
191 |         },
192 |         "node_modules/@lezer/lr": {
193 |             "version": "1.4.2",
194 |             "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.2.tgz",
195 |             "integrity": "sha512-pu0K1jCIdnQ12aWNaAVU5bzi7Bd1w54J3ECgANPmYLtQKP0HBj2cE/5coBD66MT10xbtIuUr7tg0Shbsvk0mDA==",
196 |             "license": "MIT",
197 |             "dependencies": {
198 |                 "@lezer/common": "^1.0.0"
199 |             }
200 |         },
201 |         "node_modules/@rollup/plugin-node-resolve": {
202 |             "version": "15.3.0",
203 |             "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.0.tgz",
204 |             "integrity": "sha512-9eO5McEICxMzJpDW9OnMYSv4Sta3hmt7VtBFz5zR9273suNOydOyq/FrGeGy+KsTRFm8w0SLVhzig2ILFT63Ag==",
205 |             "license": "MIT",
206 |             "dependencies": {
207 |                 "@rollup/pluginutils": "^5.0.1",
208 |                 "@types/resolve": "1.20.2",
209 |                 "deepmerge": "^4.2.2",
210 |                 "is-module": "^1.0.0",
211 |                 "resolve": "^1.22.1"
212 |             },
213 |             "engines": {
214 |                 "node": ">=14.0.0"
215 |             },
216 |             "peerDependencies": {
217 |                 "rollup": "^2.78.0||^3.0.0||^4.0.0"
218 |             },
219 |             "peerDependenciesMeta": {
220 |                 "rollup": {
221 |                     "optional": true
222 |                 }
223 |             }
224 |         },
225 |         "node_modules/@rollup/pluginutils": {
226 |             "version": "5.1.3",
227 |             "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.3.tgz",
228 |             "integrity": "sha512-Pnsb6f32CD2W3uCaLZIzDmeFyQ2b8UWMFI7xtwUezpcGBDVDW6y9XgAWIlARiGAo6eNF5FK5aQTr0LFyNyqq5A==",
229 |             "license": "MIT",
230 |             "dependencies": {
231 |                 "@types/estree": "^1.0.0",
232 |                 "estree-walker": "^2.0.2",
233 |                 "picomatch": "^4.0.2"
234 |             },
235 |             "engines": {
236 |                 "node": ">=14.0.0"
237 |             },
238 |             "peerDependencies": {
239 |                 "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
240 |             },
241 |             "peerDependenciesMeta": {
242 |                 "rollup": {
243 |                     "optional": true
244 |                 }
245 |             }
246 |         },
247 |         "node_modules/@types/estree": {
248 |             "version": "1.0.6",
249 |             "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
250 |             "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
251 |             "license": "MIT"
252 |         },
253 |         "node_modules/@types/resolve": {
254 |             "version": "1.20.2",
255 |             "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
256 |             "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==",
257 |             "license": "MIT"
258 |         },
259 |         "node_modules/acorn": {
260 |             "version": "8.14.0",
261 |             "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
262 |             "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
263 |             "license": "MIT",
264 |             "bin": {
265 |                 "acorn": "bin/acorn"
266 |             },
267 |             "engines": {
268 |                 "node": ">=0.4.0"
269 |             }
270 |         },
271 |         "node_modules/buffer-from": {
272 |             "version": "1.1.2",
273 |             "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
274 |             "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
275 |             "license": "MIT"
276 |         },
277 |         "node_modules/camel-case": {
278 |             "version": "4.1.2",
279 |             "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz",
280 |             "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==",
281 |             "license": "MIT",
282 |             "dependencies": {
283 |                 "pascal-case": "^3.1.2",
284 |                 "tslib": "^2.0.3"
285 |             }
286 |         },
287 |         "node_modules/clean-css": {
288 |             "version": "5.3.3",
289 |             "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz",
290 |             "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==",
291 |             "license": "MIT",
292 |             "dependencies": {
293 |                 "source-map": "~0.6.0"
294 |             },
295 |             "engines": {
296 |                 "node": ">= 10.0"
297 |             }
298 |         },
299 |         "node_modules/commander": {
300 |             "version": "10.0.1",
301 |             "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz",
302 |             "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==",
303 |             "license": "MIT",
304 |             "engines": {
305 |                 "node": ">=14"
306 |             }
307 |         },
308 |         "node_modules/crelt": {
309 |             "version": "1.0.6",
310 |             "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
311 |             "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
312 |             "license": "MIT"
313 |         },
314 |         "node_modules/css-b64-images": {
315 |             "version": "0.2.5",
316 |             "resolved": "https://registry.npmjs.org/css-b64-images/-/css-b64-images-0.2.5.tgz",
317 |             "integrity": "sha512-TgQBEdP07adhrDfXvI5o6bHGukKBNMzp2Ngckc/6d09zpjD2gc1Hl3Ca1CKgb8FXjHi88+Phv2Uegs2kTL4zjg==",
318 |             "bin": {
319 |                 "css-b64-images": "bin/css-b64-images"
320 |             },
321 |             "engines": {
322 |                 "node": "*"
323 |             }
324 |         },
325 |         "node_modules/debug": {
326 |             "version": "4.3.7",
327 |             "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
328 |             "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
329 |             "license": "MIT",
330 |             "dependencies": {
331 |                 "ms": "^2.1.3"
332 |             },
333 |             "engines": {
334 |                 "node": ">=6.0"
335 |             },
336 |             "peerDependenciesMeta": {
337 |                 "supports-color": {
338 |                     "optional": true
339 |                 }
340 |             }
341 |         },
342 |         "node_modules/deepmerge": {
343 |             "version": "4.3.1",
344 |             "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
345 |             "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
346 |             "license": "MIT",
347 |             "engines": {
348 |                 "node": ">=0.10.0"
349 |             }
350 |         },
351 |         "node_modules/dot-case": {
352 |             "version": "3.0.4",
353 |             "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz",
354 |             "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==",
355 |             "license": "MIT",
356 |             "dependencies": {
357 |                 "no-case": "^3.0.4",
358 |                 "tslib": "^2.0.3"
359 |             }
360 |         },
361 |         "node_modules/entities": {
362 |             "version": "4.5.0",
363 |             "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
364 |             "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
365 |             "license": "BSD-2-Clause",
366 |             "engines": {
367 |                 "node": ">=0.12"
368 |             },
369 |             "funding": {
370 |                 "url": "https://github.com/fb55/entities?sponsor=1"
371 |             }
372 |         },
373 |         "node_modules/estree-walker": {
374 |             "version": "2.0.2",
375 |             "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
376 |             "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
377 |             "license": "MIT"
378 |         },
379 |         "node_modules/find-up": {
380 |             "version": "6.3.0",
381 |             "resolved": "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz",
382 |             "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
383 |             "license": "MIT",
384 |             "dependencies": {
385 |                 "locate-path": "^7.1.0",
386 |                 "path-exists": "^5.0.0"
387 |             },
388 |             "engines": {
389 |                 "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
390 |             },
391 |             "funding": {
392 |                 "url": "https://github.com/sponsors/sindresorhus"
393 |             }
394 |         },
395 |         "node_modules/fsevents": {
396 |             "version": "2.3.3",
397 |             "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
398 |             "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
399 |             "hasInstallScript": true,
400 |             "license": "MIT",
401 |             "optional": true,
402 |             "os": [
403 |                 "darwin"
404 |             ],
405 |             "engines": {
406 |                 "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
407 |             }
408 |         },
409 |         "node_modules/function-bind": {
410 |             "version": "1.1.2",
411 |             "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
412 |             "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
413 |             "license": "MIT",
414 |             "funding": {
415 |                 "url": "https://github.com/sponsors/ljharb"
416 |             }
417 |         },
418 |         "node_modules/hasown": {
419 |             "version": "2.0.2",
420 |             "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
421 |             "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
422 |             "license": "MIT",
423 |             "dependencies": {
424 |                 "function-bind": "^1.1.2"
425 |             },
426 |             "engines": {
427 |                 "node": ">= 0.4"
428 |             }
429 |         },
430 |         "node_modules/html-minifier-terser": {
431 |             "version": "7.2.0",
432 |             "resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-7.2.0.tgz",
433 |             "integrity": "sha512-tXgn3QfqPIpGl9o+K5tpcj3/MN4SfLtsx2GWwBC3SSd0tXQGyF3gsSqad8loJgKZGM3ZxbYDd5yhiBIdWpmvLA==",
434 |             "license": "MIT",
435 |             "dependencies": {
436 |                 "camel-case": "^4.1.2",
437 |                 "clean-css": "~5.3.2",
438 |                 "commander": "^10.0.0",
439 |                 "entities": "^4.4.0",
440 |                 "param-case": "^3.0.4",
441 |                 "relateurl": "^0.2.7",
442 |                 "terser": "^5.15.1"
443 |             },
444 |             "bin": {
445 |                 "html-minifier-terser": "cli.js"
446 |             },
447 |             "engines": {
448 |                 "node": "^14.13.1 || >=16.0.0"
449 |             }
450 |         },
451 |         "node_modules/is-core-module": {
452 |             "version": "2.15.1",
453 |             "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz",
454 |             "integrity": "sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==",
455 |             "license": "MIT",
456 |             "dependencies": {
457 |                 "hasown": "^2.0.2"
458 |             },
459 |             "engines": {
460 |                 "node": ">= 0.4"
461 |             },
462 |             "funding": {
463 |                 "url": "https://github.com/sponsors/ljharb"
464 |             }
465 |         },
466 |         "node_modules/is-module": {
467 |             "version": "1.0.0",
468 |             "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
469 |             "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==",
470 |             "license": "MIT"
471 |         },
472 |         "node_modules/jju": {
473 |             "version": "1.4.0",
474 |             "resolved": "https://registry.npmjs.org/jju/-/jju-1.4.0.tgz",
475 |             "integrity": "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==",
476 |             "license": "MIT"
477 |         },
478 |         "node_modules/locate-path": {
479 |             "version": "7.2.0",
480 |             "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
481 |             "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
482 |             "license": "MIT",
483 |             "dependencies": {
484 |                 "p-locate": "^6.0.0"
485 |             },
486 |             "engines": {
487 |                 "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
488 |             },
489 |             "funding": {
490 |                 "url": "https://github.com/sponsors/sindresorhus"
491 |             }
492 |         },
493 |         "node_modules/lower-case": {
494 |             "version": "2.0.2",
495 |             "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz",
496 |             "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==",
497 |             "license": "MIT",
498 |             "dependencies": {
499 |                 "tslib": "^2.0.3"
500 |             }
501 |         },
502 |         "node_modules/minify": {
503 |             "version": "9.2.0",
504 |             "resolved": "https://registry.npmjs.org/minify/-/minify-9.2.0.tgz",
505 |             "integrity": "sha512-dfVx8j27TIZy2EE/nVMAhTVmUo6tdO4gYbKXaCYPUmpqWN2QJBgQtPfofsoA658L3Ee7e5OcyFIncJRgFtZcqQ==",
506 |             "license": "MIT",
507 |             "dependencies": {
508 |                 "clean-css": "^5.0.1",
509 |                 "css-b64-images": "~0.2.5",
510 |                 "debug": "^4.1.0",
511 |                 "find-up": "^6.1.0",
512 |                 "html-minifier-terser": "^7.1.0",
513 |                 "readjson": "^2.2.2",
514 |                 "simport": "^1.2.0",
515 |                 "terser": "^5.3.2",
516 |                 "try-catch": "^3.0.0",
517 |                 "try-to-catch": "^3.0.0"
518 |             },
519 |             "bin": {
520 |                 "minify": "bin/minify.js"
521 |             },
522 |             "engines": {
523 |                 "node": ">=16"
524 |             }
525 |         },
526 |         "node_modules/ms": {
527 |             "version": "2.1.3",
528 |             "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
529 |             "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
530 |             "license": "MIT"
531 |         },
532 |         "node_modules/no-case": {
533 |             "version": "3.0.4",
534 |             "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz",
535 |             "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==",
536 |             "license": "MIT",
537 |             "dependencies": {
538 |                 "lower-case": "^2.0.2",
539 |                 "tslib": "^2.0.3"
540 |             }
541 |         },
542 |         "node_modules/p-limit": {
543 |             "version": "4.0.0",
544 |             "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
545 |             "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
546 |             "license": "MIT",
547 |             "dependencies": {
548 |                 "yocto-queue": "^1.0.0"
549 |             },
550 |             "engines": {
551 |                 "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
552 |             },
553 |             "funding": {
554 |                 "url": "https://github.com/sponsors/sindresorhus"
555 |             }
556 |         },
557 |         "node_modules/p-locate": {
558 |             "version": "6.0.0",
559 |             "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
560 |             "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
561 |             "license": "MIT",
562 |             "dependencies": {
563 |                 "p-limit": "^4.0.0"
564 |             },
565 |             "engines": {
566 |                 "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
567 |             },
568 |             "funding": {
569 |                 "url": "https://github.com/sponsors/sindresorhus"
570 |             }
571 |         },
572 |         "node_modules/param-case": {
573 |             "version": "3.0.4",
574 |             "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz",
575 |             "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==",
576 |             "license": "MIT",
577 |             "dependencies": {
578 |                 "dot-case": "^3.0.4",
579 |                 "tslib": "^2.0.3"
580 |             }
581 |         },
582 |         "node_modules/pascal-case": {
583 |             "version": "3.1.2",
584 |             "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz",
585 |             "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==",
586 |             "license": "MIT",
587 |             "dependencies": {
588 |                 "no-case": "^3.0.4",
589 |                 "tslib": "^2.0.3"
590 |             }
591 |         },
592 |         "node_modules/path-exists": {
593 |             "version": "5.0.0",
594 |             "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
595 |             "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
596 |             "license": "MIT",
597 |             "engines": {
598 |                 "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
599 |             }
600 |         },
601 |         "node_modules/path-parse": {
602 |             "version": "1.0.7",
603 |             "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
604 |             "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
605 |             "license": "MIT"
606 |         },
607 |         "node_modules/picomatch": {
608 |             "version": "4.0.2",
609 |             "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
610 |             "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
611 |             "license": "MIT",
612 |             "engines": {
613 |                 "node": ">=12"
614 |             },
615 |             "funding": {
616 |                 "url": "https://github.com/sponsors/jonschlinkert"
617 |             }
618 |         },
619 |         "node_modules/readjson": {
620 |             "version": "2.2.2",
621 |             "resolved": "https://registry.npmjs.org/readjson/-/readjson-2.2.2.tgz",
622 |             "integrity": "sha512-PdeC9tsmLWBiL8vMhJvocq+OezQ3HhsH2HrN7YkhfYcTjQSa/iraB15A7Qvt7Xpr0Yd2rDNt6GbFwVQDg3HcAw==",
623 |             "license": "MIT",
624 |             "dependencies": {
625 |                 "jju": "^1.4.0",
626 |                 "try-catch": "^3.0.0"
627 |             },
628 |             "engines": {
629 |                 "node": ">=10"
630 |             }
631 |         },
632 |         "node_modules/relateurl": {
633 |             "version": "0.2.7",
634 |             "resolved": "https://registry.npmjs.org/relateurl/-/relateurl-0.2.7.tgz",
635 |             "integrity": "sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==",
636 |             "license": "MIT",
637 |             "engines": {
638 |                 "node": ">= 0.10"
639 |             }
640 |         },
641 |         "node_modules/resolve": {
642 |             "version": "1.22.8",
643 |             "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz",
644 |             "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==",
645 |             "license": "MIT",
646 |             "dependencies": {
647 |                 "is-core-module": "^2.13.0",
648 |                 "path-parse": "^1.0.7",
649 |                 "supports-preserve-symlinks-flag": "^1.0.0"
650 |             },
651 |             "bin": {
652 |                 "resolve": "bin/resolve"
653 |             },
654 |             "funding": {
655 |                 "url": "https://github.com/sponsors/ljharb"
656 |             }
657 |         },
658 |         "node_modules/rollup": {
659 |             "version": "3.29.5",
660 |             "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.5.tgz",
661 |             "integrity": "sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w==",
662 |             "license": "MIT",
663 |             "bin": {
664 |                 "rollup": "dist/bin/rollup"
665 |             },
666 |             "engines": {
667 |                 "node": ">=14.18.0",
668 |                 "npm": ">=8.0.0"
669 |             },
670 |             "optionalDependencies": {
671 |                 "fsevents": "~2.3.2"
672 |             }
673 |         },
674 |         "node_modules/simport": {
675 |             "version": "1.2.0",
676 |             "resolved": "https://registry.npmjs.org/simport/-/simport-1.2.0.tgz",
677 |             "integrity": "sha512-85Bm7pKsqiiQ8rmYCaPDdlXZjJvuW6/k/FY8MTtLFMgU7f8S00CgTHfRtWB6KwSb6ek4p9YyG2enG1+yJbl+CA==",
678 |             "license": "MIT",
679 |             "dependencies": {
680 |                 "readjson": "^2.2.0",
681 |                 "try-to-catch": "^3.0.0"
682 |             },
683 |             "engines": {
684 |                 "node": ">=12.2"
685 |             }
686 |         },
687 |         "node_modules/source-map": {
688 |             "version": "0.6.1",
689 |             "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
690 |             "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
691 |             "license": "BSD-3-Clause",
692 |             "engines": {
693 |                 "node": ">=0.10.0"
694 |             }
695 |         },
696 |         "node_modules/source-map-support": {
697 |             "version": "0.5.21",
698 |             "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
699 |             "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
700 |             "license": "MIT",
701 |             "dependencies": {
702 |                 "buffer-from": "^1.0.0",
703 |                 "source-map": "^0.6.0"
704 |             }
705 |         },
706 |         "node_modules/style-mod": {
707 |             "version": "4.1.2",
708 |             "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.2.tgz",
709 |             "integrity": "sha512-wnD1HyVqpJUI2+eKZ+eo1UwghftP6yuFheBqqe+bWCotBjC2K1YnteJILRMs3SM4V/0dLEW1SC27MWP5y+mwmw==",
710 |             "license": "MIT"
711 |         },
712 |         "node_modules/supports-preserve-symlinks-flag": {
713 |             "version": "1.0.0",
714 |             "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
715 |             "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
716 |             "license": "MIT",
717 |             "engines": {
718 |                 "node": ">= 0.4"
719 |             },
720 |             "funding": {
721 |                 "url": "https://github.com/sponsors/ljharb"
722 |             }
723 |         },
724 |         "node_modules/terser": {
725 |             "version": "5.36.0",
726 |             "resolved": "https://registry.npmjs.org/terser/-/terser-5.36.0.tgz",
727 |             "integrity": "sha512-IYV9eNMuFAV4THUspIRXkLakHnV6XO7FEdtKjf/mDyrnqUg9LnlOn6/RwRvM9SZjR4GUq8Nk8zj67FzVARr74w==",
728 |             "license": "BSD-2-Clause",
729 |             "dependencies": {
730 |                 "@jridgewell/source-map": "^0.3.3",
731 |                 "acorn": "^8.8.2",
732 |                 "commander": "^2.20.0",
733 |                 "source-map-support": "~0.5.20"
734 |             },
735 |             "bin": {
736 |                 "terser": "bin/terser"
737 |             },
738 |             "engines": {
739 |                 "node": ">=10"
740 |             }
741 |         },
742 |         "node_modules/terser/node_modules/commander": {
743 |             "version": "2.20.3",
744 |             "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
745 |             "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
746 |             "license": "MIT"
747 |         },
748 |         "node_modules/try-catch": {
749 |             "version": "3.0.1",
750 |             "resolved": "https://registry.npmjs.org/try-catch/-/try-catch-3.0.1.tgz",
751 |             "integrity": "sha512-91yfXw1rr/P6oLpHSyHDOHm0vloVvUoo9FVdw8YwY05QjJQG9OT0LUxe2VRAzmHG+0CUOmI3nhxDUMLxDN/NEQ==",
752 |             "license": "MIT",
753 |             "engines": {
754 |                 "node": ">=6"
755 |             }
756 |         },
757 |         "node_modules/try-to-catch": {
758 |             "version": "3.0.1",
759 |             "resolved": "https://registry.npmjs.org/try-to-catch/-/try-to-catch-3.0.1.tgz",
760 |             "integrity": "sha512-hOY83V84Hx/1sCzDSaJA+Xz2IIQOHRvjxzt+F0OjbQGPZ6yLPLArMA0gw/484MlfUkQbCpKYMLX3VDCAjWKfzQ==",
761 |             "license": "MIT",
762 |             "engines": {
763 |                 "node": ">=6"
764 |             }
765 |         },
766 |         "node_modules/tslib": {
767 |             "version": "2.8.1",
768 |             "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
769 |             "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
770 |             "license": "0BSD"
771 |         },
772 |         "node_modules/w3c-keyname": {
773 |             "version": "2.2.8",
774 |             "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
775 |             "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
776 |             "license": "MIT"
777 |         },
778 |         "node_modules/yocto-queue": {
779 |             "version": "1.1.1",
780 |             "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz",
781 |             "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==",
782 |             "license": "MIT",
783 |             "engines": {
784 |                 "node": ">=12.20"
785 |             },
786 |             "funding": {
787 |                 "url": "https://github.com/sponsors/sindresorhus"
788 |             }
789 |         }
790 |     }
791 | }
792 | 


--------------------------------------------------------------------------------
/src/muffin.js:
--------------------------------------------------------------------------------
   1 | /*--- The tokenizer! ---*/
   2 | 
   3 | const TokenKind = {
   4 |     KEY_PHRASE: 0,  // "set up"
   5 |     PHRASE: 1,  // "Muffin"
   6 |     NUMBER: 2,  // "42"
   7 |     NUMBER_PERIOD: 3,  // "2."
   8 |     COMMA: 4,  // ","
   9 |     ORDINAL: 5,  // "1st"
  10 |     NEW_LINE: 6,
  11 |     TEMPERATURE: 7,  // "180C"
  12 |     EOF: 8,
  13 |     STRING: 9,  // "Hello, world!"
  14 |     COLON: 10,  // ":"
  15 | };
  16 | 
  17 | // For diagnostics
  18 | const TokenNames = Object.fromEntries(
  19 |     Object.entries(TokenKind).map((x) => x.reverse())
  20 | );
  21 | 
  22 | class Loc {
  23 |     constructor(line_no, col_no, char_index) {
  24 |         this.line_no = line_no;
  25 |         this.col_no = col_no;
  26 |         this.char_index = char_index;
  27 |     }
  28 | }
  29 | 
  30 | class Token {
  31 |     constructor(kind, loc, value=null) {
  32 |         this.kind = kind;
  33 |         this.value = value;
  34 |         this.loc = loc;
  35 |     }
  36 | };
  37 | 
  38 | export class CompileError {
  39 |     constructor(message, loc) {
  40 |         this.message = message;
  41 |         this.loc = loc;  // Loc or null
  42 |     }
  43 |     format() {
  44 |         if (this.loc == null) {
  45 |             return this.message;
  46 |         }
  47 |         return `${this.loc.line_no}:${this.loc.col_no}: ${this.message}`;
  48 |     }
  49 | }
  50 | 
  51 | const ordinal_suffixes = ['st', 'nd', 'rd', 'th'];
  52 | const key_phrases = new Set([
  53 |     'set up',
  54 |     'set up a',
  55 |     'add',
  56 |     'into',
  57 |     'add water to',
  58 |     'at a',
  59 |     'ratio',
  60 |     'pour half of contents of',
  61 |     'remove',
  62 |     'from',
  63 |     'if',
  64 |     'is empty',
  65 |     'is not empty',
  66 |     'proceed to step',
  67 |     'place',
  68 |     'in the oven and bake at',
  69 |     'clean',
  70 |     'pour contents of',
  71 |     'go back to step',
  72 |     'serves',
  73 |     'recipe',
  74 |     'ingredients',
  75 |     'method',
  76 |     'grams of',
  77 |     'brand',
  78 |     'remove a layer from',
  79 |     'and dump into',
  80 |     'microwave',
  81 |     'serve with',
  82 |     'in grill mode',
  83 |     'stir the mixture in',
  84 |     'until smooth',
  85 |     'sift the mixture in',
  86 |     'whip the mixture in',
  87 |     'bring the mixture in',
  88 |     'to a boil',
  89 | ]);
  90 | const operators = new Map([
  91 |     [",", TokenKind.COMMA],
  92 |     [":", TokenKind.COLON],
  93 | ])
  94 | 
  95 | class Tokenizer {
  96 |     constructor(str) {
  97 |         this.str = str;
  98 |         this.ptr = 1;
  99 |         this.c = this.str[0];
 100 |         this.line_no = 0;
 101 |     }
 102 |     advance() {
 103 |         this.c = this.str[this.ptr++];
 104 |         this.col_no++;
 105 |     }
 106 |     advance2(chars) {
 107 |         this.ptr += chars;
 108 |         this.col_no += chars;
 109 |         this.c = this.str[this.ptr - 1];
 110 |     }
 111 |     complain(message, loc=null) {
 112 |         if (loc == null) {
 113 |             loc = this.export_state();
 114 |         }
 115 |         throw new CompileError(message, loc);
 116 |     }
 117 |     skip_ws() {
 118 |         while (this.c == ' ' || this.c == '\t') {
 119 |             this.advance();
 120 |         }
 121 |     }
 122 |     regex_match(regex) {
 123 |         regex.lastIndex = this.ptr - 1;
 124 |         return regex.exec(this.str);
 125 |     }
 126 |     export_state() {
 127 |         return new Loc(this.line_no, this.col_no, this.ptr - 1);
 128 |     }
 129 |     make_token(kind, value=null, loc=null) {
 130 |         if (loc == null) {
 131 |             loc = this.export_state();
 132 |         }
 133 |         return new Token(kind, loc, value);
 134 |     }
 135 |     parse_line() {
 136 |         const res = [];
 137 |         this.col_no = 1;
 138 |         this.line_no++;
 139 |         while (this.c != '\n' && this.c != undefined) {
 140 |             this.skip_ws()
 141 |             const digit = /\d+/y;
 142 |             const word = /[a-zA-Z]\w*/y;
 143 |             const number_result = this.regex_match(digit);
 144 |             let word_result = this.regex_match(word);
 145 |             if (number_result) {
 146 |                 const state = this.export_state();
 147 |                 const match = number_result[0];
 148 |                 this.advance2(match.length);
 149 |                 const number = parseInt(match);
 150 |                 // Check for suffixes
 151 |                 const num_suffix = /\.|\w*/y;
 152 |                 const num_suffix_result = this.regex_match(num_suffix);
 153 |                 const suffix_match = num_suffix_result[0];
 154 |                 if (suffix_match == '.') {
 155 |                     res.push(this.make_token(
 156 |                         TokenKind.NUMBER_PERIOD, number, state
 157 |                     ));
 158 |                 }
 159 |                 else if (suffix_match == 'C' || suffix_match == 'F') {
 160 |                     res.push(this.make_token(
 161 |                         TokenKind.TEMPERATURE, number + suffix_match, state
 162 |                     ));
 163 |                 }
 164 |                 else if (ordinal_suffixes.includes(suffix_match)) {
 165 |                     // TODO make sure suffix is correct
 166 |                     res.push(this.make_token(
 167 |                         TokenKind.ORDINAL, number, state
 168 |                     ));
 169 |                 }
 170 |                 else if (suffix_match.length == 0) {
 171 |                     res.push(this.make_token(TokenKind.NUMBER, number, state));
 172 |                 }
 173 |                 else {
 174 |                     this.complain(`unknown number suffix ${suffix_match}`);
 175 |                 }
 176 |                 this.advance2(suffix_match.length);
 177 |             }
 178 |             else if (word_result) {
 179 |                 // Phrase
 180 |                 const state = this.export_state();
 181 |                 const first_char = word_result[0][0];
 182 |                 const is_kw = first_char.toLowerCase() == first_char;
 183 |                 const word2 = is_kw ? /[a-z]\w*/y : /[A-Z]\w*/y;
 184 |                 const word_list = [];
 185 |                 do {
 186 |                     const match = word_result[0];
 187 |                     word_list.push(match);
 188 |                     this.advance2(match.length);
 189 |                     this.skip_ws();
 190 |                     word_result = this.regex_match(word2);
 191 |                 } while (word_result);
 192 |                 const phrase = word_list.join(' ');
 193 |                 if (is_kw) {
 194 |                     if (key_phrases.has(phrase)) {
 195 |                         res.push(this.make_token(
 196 |                             TokenKind.KEY_PHRASE, phrase, state
 197 |                         ));
 198 |                     }
 199 |                     else {
 200 |                         this.complain(
 201 |                             `unknown key phrase "${phrase}"; identifiers must `
 202 |                             + `be Title Case`, state
 203 |                         );
 204 |                     }
 205 |                 }
 206 |                 else {
 207 |                     res.push(this.make_token(TokenKind.PHRASE, phrase, state));
 208 |                 }
 209 |             }
 210 |             else if (this.c == '"') {
 211 |                 // String
 212 |                 const state = this.export_state();
 213 |                 this.advance();
 214 |                 while (this.c != '"') {
 215 |                     if (this.c == '\n' || this.c == undefined) {
 216 |                         this.complain("unterminated string", state);
 217 |                     }
 218 |                     this.advance();
 219 |                 }
 220 |                 res.push(this.make_token(
 221 |                     TokenKind.STRING,
 222 |                     this.str.slice(state.char_index + 1, this.ptr - 1),
 223 |                     state
 224 |                 ));
 225 |                 this.advance();
 226 |             }
 227 |             else if (operators.has(this.c)) {
 228 |                 // Operator
 229 |                 res.push(this.make_token(operators.get(this.c)));
 230 |                 this.advance();
 231 |             }
 232 |             else {
 233 |                 this.complain(`invalid character "${this.c}"`);
 234 |             }
 235 |         }
 236 |         if (res.length != 0) {
 237 |             res.push(this.make_token(TokenKind.NEW_LINE));
 238 |         }
 239 |         if (this.c == '\n') {
 240 |             this.advance();
 241 |         }
 242 |         else {
 243 |             res.push(this.make_token(TokenKind.EOF));
 244 |         }
 245 |         return res;
 246 |     }
 247 | };
 248 | 
 249 | function *tokenize(str) {
 250 |     const tokenizer = new Tokenizer(str);
 251 |     while (true) {
 252 |         let buffer;
 253 |         do {
 254 |             buffer = tokenizer.parse_line();
 255 |         } while (buffer.length == 0);
 256 |         yield* buffer;
 257 |         if (buffer[buffer.length - 1].kind == TokenKind.EOF) {
 258 |             break;
 259 |         }
 260 |     }
 261 | }
 262 | 
 263 | /*--- The parser! ---*/
 264 | 
 265 | class Program {
 266 |     constructor() {
 267 |         this.recipes = new Map();  // name -> recipe
 268 |     }
 269 | }
 270 | 
 271 | class Recipe {
 272 |     constructor() {
 273 |         this.steps = [];  // Step objects
 274 |     }
 275 | }
 276 | 
 277 | const OpCodes = {
 278 |     SET_UP_BOWL: 0,  // bowl_kind, num
 279 |     SET_UP_MOLD: 1,  // mold_kind, num
 280 |     ADD_ING_TO_BOWL: 2,  // ing, bowl
 281 |     REMOVE_ING_FROM_BOWL: 3,  // ing, bowl
 282 |     CLEAN_BOWL: 4,  // bowl
 283 |     ADD_WATER_TO_BOWL: 5,  // bowl, num
 284 |     TRANSFER_HALF: 6,  // bowl1, bowl2
 285 |     TRANSFER_ALL: 7,  // bowl1, bowl2
 286 |     GO_TO: 8,  // step
 287 |     BAKE: 9,  // bowl, temperature
 288 |     SERVES: 10,  // num
 289 |     MOLD_PUSH_BOWL: 11,  // mold, bowl
 290 |     MOLD_POP: 12,  // mold
 291 |     MOLD_POP_AND_STORE: 13,  // mold, bowl
 292 |     MICROWAVE: 14,  // mold
 293 |     MOLD_PUSH_ING: 15,  // mold, ing
 294 |     SERVE_WITH: 16,  // recipe
 295 |     MICROWAVE_GRILL: 17,  // mold
 296 |     STIR_UNTIL_SMOOTH: 18,  // mold
 297 |     SIFT: 19,  // mold
 298 |     WHIP: 20,  // mold
 299 |     BOIL: 21,  // mold
 300 |     MOLD_PUSH_HALF_BOWL: 22,  // mold, bowl
 301 | };
 302 | 
 303 | const PredicateKind = {
 304 |     BOWL_IS_EMPTY: 0,  // bowl
 305 |     BOWL_NOT_EMPTY: 1,  // bowl
 306 |     MOLD_IS_EMPTY: 2,  // mold
 307 |     MOLD_NOT_EMPTY: 3,  // mold
 308 | };
 309 | 
 310 | class Step {
 311 |     constructor(content, predicate=null) {
 312 |         this.content = content;  // Object with an `op` attribute
 313 |         this.predicate = predicate;  // Null or Object with an `op` attribute
 314 |     }
 315 | }
 316 | 
 317 | function or_list(arr) {
 318 |     return arr.length == 1 ? arr[0]
 319 |         : arr.length == 2 ? arr.join(' or ')
 320 |         : arr.slice(0, -1).join(', ') + ' or ' + arr.slice(-1);
 321 | }
 322 | 
 323 | const measures = [
 324 |     'grams of',
 325 | ];
 326 | 
 327 | const bowls = [
 328 |     ["Bowl", "Bowls"],
 329 |     ["Glass Bowl", "Glass Bowls"],
 330 |     ["Mixing Bowl", "Mixing Bowls"],
 331 |     ["Plastic Bowl", "Plastic Bowls"],
 332 | ];
 333 | const molds = [
 334 |     ["Cake Mold", "Cake Molds"],
 335 |     ["Muffin Cup", "Muffin Cups"],
 336 |     ["Loaf Pan", "Loaf Pans"],
 337 |     ["Toast Mold", "Toast Molds"],
 338 |     ["Pizza Pan", "Pizza Pans"],
 339 |     ["Baking Dish", "Baking Dishes"],
 340 | ];
 341 | const valid_temperatures = [
 342 |     "190C",
 343 |     "425F",
 344 |     "230C",
 345 |     "350F",
 346 | ];
 347 | 
 348 | class Bowl {
 349 |     constructor(kind, id) {
 350 |         this.kind = kind;
 351 |         this.id = id;
 352 |     }
 353 | }
 354 | 
 355 | class Mold {
 356 |     constructor(kind, id) {
 357 |         this.kind = kind;
 358 |         this.id = id;
 359 |     }
 360 | }
 361 | 
 362 | class Parser {
 363 |     constructor(tokens) {
 364 |         this.tokens = tokens;
 365 |     }
 366 |     complain(token, message) {
 367 |         throw new CompileError(message, token.loc);
 368 |     }
 369 |     expect(...kinds) {
 370 |         let {value} = this.tokens.next();
 371 |         if (!kinds.includes(value.kind)) {
 372 |             const expecting = or_list(kinds.map((x) => TokenNames[x]));
 373 |             const got = TokenNames[value.kind];
 374 |             this.complain(value, `expecting ${expecting}, not ${got}`);
 375 |         }
 376 |         return value;
 377 |     }
 378 |     expect_keyword(...words) {
 379 |         const tok = this.expect(TokenKind.KEY_PHRASE);
 380 |         if (words.includes(tok.value)) {
 381 |             return tok.value;
 382 |         }
 383 |         const message = "expecting "
 384 |             + or_list(words.map((x) => `"${x}"`));
 385 |         this.complain(tok, message);
 386 |     }
 387 |     // Parsing rules start
 388 |     program() {
 389 |         const program = new Program();
 390 |         let tok = this.expect(TokenKind.EOF, TokenKind.PHRASE);
 391 |         while (tok.kind != TokenKind.EOF) {
 392 |             if (program.recipes.has(tok.value)) {
 393 |                 this.complain(tok, `recipe "${tok.value}" already exists`);
 394 |             }
 395 |             const recipe = new Recipe();
 396 |             program.recipes.set(tok.value, recipe);
 397 |             this.expect_keyword("recipe");
 398 |             this.expect(TokenKind.NEW_LINE);
 399 |             this.expect_keyword("ingredients");
 400 |             this.expect(TokenKind.NEW_LINE);
 401 |             this.ingredients = new Map();  // name -> value
 402 |             while (true) {
 403 |                 const tok2 = this.expect(
 404 |                     TokenKind.KEY_PHRASE, TokenKind.STRING, TokenKind.NUMBER
 405 |                 );
 406 |                 if (tok2.kind == TokenKind.KEY_PHRASE) {
 407 |                     if (tok2.value == "method") {
 408 |                         break;
 409 |                     }
 410 |                     else {
 411 |                         this.complain(
 412 |                             tok2,
 413 |                             `key phrase "${tok2.value}" can't be used here`
 414 |                         );
 415 |                     }
 416 |                 }
 417 |                 let ing;
 418 |                 if (tok2.kind == TokenKind.STRING) {
 419 |                     this.expect_keyword("brand");
 420 |                     ing = this.expect(TokenKind.PHRASE);
 421 |                 }
 422 |                 else {
 423 |                     const tok3 = this.expect(
 424 |                         TokenKind.KEY_PHRASE, TokenKind.PHRASE
 425 |                     );
 426 |                     if (tok3.kind == TokenKind.KEY_PHRASE) {
 427 |                         if (measures.includes(tok3.value)) {
 428 |                             ing = this.expect(TokenKind.PHRASE);
 429 |                         }
 430 |                         else {
 431 |                             this.complain(
 432 |                                 tok3,
 433 |                                 `key phrase "${tok2.value}" is not a measure`
 434 |                             );
 435 |                         }
 436 |                     }
 437 |                     else {
 438 |                         ing = tok3;
 439 |                     }
 440 |                 }
 441 |                 this.expect(TokenKind.NEW_LINE);
 442 |                 const ing_name = ing.value;
 443 |                 if (this.ingredients.has(ing_name)) {
 444 |                     this.complain(ing, `ingredient "${ing_name}" used twice`);
 445 |                 }
 446 |                 this.ingredients.set(ing_name, tok2.value);
 447 |             }
 448 |             this.expect(TokenKind.NEW_LINE);
 449 |             let i = 1;
 450 |             while (true) {
 451 |                 tok = this.expect(
 452 |                     TokenKind.EOF, TokenKind.PHRASE, TokenKind.NUMBER_PERIOD
 453 |                 );
 454 |                 if (tok.kind != TokenKind.NUMBER_PERIOD) {
 455 |                     break;
 456 |                 }
 457 |                 if (i != tok.value) {
 458 |                     this.complain(tok, `wrong label; should be "${i}."`);
 459 |                 }
 460 |                 let predicate = null;
 461 |                 let tok2 = this.expect(TokenKind.KEY_PHRASE);
 462 |                 if (tok2.value == "if") {
 463 |                     predicate = this.predicate();
 464 |                     tok2 = this.expect(TokenKind.KEY_PHRASE);
 465 |                 }
 466 |                 const step_content = this.step_content(tok2, i);
 467 |                 recipe.steps.push(new Step(step_content, predicate));
 468 |                 i++;
 469 |             }
 470 |         }
 471 |         this.ingredients = undefined;  // Allow GC
 472 |         return program;
 473 |     }
 474 |     bowl_or_mold_impl(predicate, name) {
 475 |         let tok = this.expect(TokenKind.ORDINAL, TokenKind.PHRASE);
 476 |         let id;
 477 |         if (tok.kind == TokenKind.ORDINAL) {
 478 |             id = tok.value;
 479 |             if (id <= 0) {
 480 |                 this.complain(tok, `invalid ordinal ${id}`);
 481 |             }
 482 |             tok = this.expect(TokenKind.PHRASE);
 483 |         }
 484 |         else {
 485 |             id = 1;
 486 |         }
 487 |         const value = tok.value;
 488 |         const kind = predicate(value);
 489 |         if (kind == undefined) {
 490 |             this.complain(
 491 |                 tok, `"${tok.value}" is not a valid ${name} name`
 492 |             );
 493 |         }
 494 |         return [kind, new (kind == "bowl" ? Bowl : Mold)(tok.value, id)];
 495 |     }
 496 |     bowl_or_mold() {
 497 |         return this.bowl_or_mold_impl(
 498 |             (value) => {
 499 |                 if (bowls.some((x) => x[0] == value)) {
 500 |                     return "bowl";
 501 |                 }
 502 |                 else if (molds.some((x) => x[0] == value)) {
 503 |                     return "mold";
 504 |                 }
 505 |                 else {
 506 |                     return null;
 507 |                 }
 508 |             },
 509 |             "bowl/mold"
 510 |         );
 511 |     }
 512 |     bowl() {
 513 |         const [kind, bowl] = this.bowl_or_mold_impl(
 514 |             (value) => bowls.some((x) => x[0] == value) ? "bowl" : null,
 515 |             "bowl"
 516 |         );
 517 |         return bowl;
 518 |     }
 519 |     mold() {
 520 |         const [kind, mold] = this.bowl_or_mold_impl(
 521 |             (value) => molds.some((x) => x[0] == value) ? "bowl" : null,
 522 |             "mold"
 523 |         );
 524 |         return mold;
 525 |     }
 526 |     predicate() {
 527 |         const [kind, subject] = this.bowl_or_mold();
 528 |         const empty =
 529 |             this.expect_keyword("is empty", "is not empty") == "is empty";
 530 |         this.expect(TokenKind.COMMA);
 531 |         let ret;
 532 |         if (kind == "bowl") {
 533 |             ret = {
 534 |                 op: empty ? PredicateKind.BOWL_IS_EMPTY
 535 |                     : PredicateKind.BOWL_NOT_EMPTY,
 536 |                 bowl: subject
 537 |             };
 538 |         }
 539 |         else {
 540 |             ret = {
 541 |                 op: empty ? PredicateKind.MOLD_IS_EMPTY
 542 |                     : PredicateKind.MOLD_NOT_EMPTY,
 543 |                 mold: subject
 544 |             };
 545 |         }
 546 |         return ret;
 547 |     }
 548 |     ingredient_impl() {
 549 |         const tok = this.expect(TokenKind.PHRASE);
 550 |         const value = this.ingredients.get(tok.value);
 551 |         if (value == undefined) {
 552 |             this.complain(tok, `undefined ingredient "${tok.value}"`);
 553 |         }
 554 |         return [tok, value];
 555 |     }
 556 |     int_ingredient() {
 557 |         const [tok, value] = this.ingredient_impl();
 558 |         if (typeof value == "string") {
 559 |             this.complain(
 560 |                 tok,
 561 |                 `cannot use string type ingredient "${tok.value}" here`
 562 |             );
 563 |         }
 564 |         return value;
 565 |     }
 566 |     positive_int() {
 567 |         const num = this.expect(TokenKind.NUMBER);
 568 |         if (num.value <= 0) {
 569 |             this.complain(num, `should be positive, not ${num.value}`);
 570 |         }
 571 |         return num.value;
 572 |     }
 573 |     step_content(tok, step_num) {
 574 |         let ret;
 575 |         let consume_new_line = true;
 576 |         switch (tok.value) {
 577 |             case "set up a": {
 578 |                 const tok = this.expect(TokenKind.PHRASE);
 579 |                 if (bowls.some((x) => x[0] == tok.value)) {
 580 |                     ret = {op: OpCodes.SET_UP_BOWL, bowl_kind: tok.value};
 581 |                 }
 582 |                 else if (molds.some((x) => x[0] == tok.value)) {
 583 |                     ret = {op: OpCodes.SET_UP_MOLD, mold_kind: tok.value};
 584 |                 }
 585 |                 else {
 586 |                     this.complain(
 587 |                         tok, `"${tok.value}" is not a valid bowl/mold name`
 588 |                     );
 589 |                 }
 590 |                 ret.num = 1;
 591 |                 break;
 592 |             }
 593 |             case "set up": {
 594 |                 const num = this.positive_int();
 595 |                 const tok = this.expect(TokenKind.PHRASE);
 596 |                 const idx = +(num > 1);
 597 |                 const bowl = bowls.find((x) => x[idx] == tok.value);
 598 |                 if (bowl) {
 599 |                     ret = {op: OpCodes.SET_UP_BOWL, bowl_kind: bowl[0]};
 600 |                 }
 601 |                 else {
 602 |                     const mold = molds.find((x) => x[idx] == tok.value);
 603 |                     if (mold) {
 604 |                         ret = {op: OpCodes.SET_UP_MOLD, mold_kind: mold[0]};
 605 |                     }
 606 |                     else {
 607 |                         this.complain(
 608 |                             tok, `"${tok.value}" is not a valid bowl/mold name`
 609 |                         );
 610 |                     }
 611 |                 }
 612 |                 ret.num = num;
 613 |                 break;
 614 |             }
 615 |             case "add": {
 616 |                 const [tok, value] = this.ingredient_impl();
 617 |                 this.expect_keyword("into");
 618 |                 const [kind, ob] = this.bowl_or_mold();
 619 |                 if (kind == "bowl") {
 620 |                     if (typeof value == "string") {
 621 |                         this.complain(
 622 |                             tok,
 623 |                             "can only add string ingredient to molds"
 624 |                         );
 625 |                     }
 626 |                     ret = {op: OpCodes.ADD_ING_TO_BOWL, bowl: ob};
 627 |                 }
 628 |                 else {
 629 |                     ret = {op: OpCodes.MOLD_PUSH_ING, mold: ob};
 630 |                 }
 631 |                 ret.ing = value;
 632 |                 break;
 633 |             }
 634 |             case "remove": {
 635 |                 const value = this.int_ingredient();
 636 |                 this.expect_keyword("from");
 637 |                 const bowl = this.bowl();
 638 |                 ret = {
 639 |                     op: OpCodes.REMOVE_ING_FROM_BOWL, bowl: bowl, ing: value
 640 |                 };
 641 |                 break;
 642 |             }
 643 |             case "clean": {
 644 |                 const bowl = this.bowl();
 645 |                 ret = {op: OpCodes.CLEAN_BOWL, bowl: bowl};
 646 |                 break;
 647 |             }
 648 |             case "add water to": {
 649 |                 const bowl = this.bowl();
 650 |                 this.expect_keyword("at a");
 651 |                 const one = this.expect(TokenKind.NUMBER);
 652 |                 if (one.value != 1) {
 653 |                     this.complain(
 654 |                         one,
 655 |                         `left hand side of ratio must be 1, not ${one.value}`
 656 |                     );
 657 |                 }
 658 |                 this.expect(TokenKind.COLON);
 659 |                 const num = this.positive_int();
 660 |                 this.expect_keyword("ratio");
 661 |                 ret = {op: OpCodes.ADD_WATER_TO_BOWL, bowl: bowl, num: num};
 662 |                 break;
 663 |             }
 664 |             case "pour half of contents of": {
 665 |                 const bowl1 = this.bowl();
 666 |                 this.expect_keyword("into");
 667 |                 const [kind, second] = this.bowl_or_mold();
 668 |                 ret = kind == "bowl" ?
 669 |                     {op: OpCodes.TRANSFER_HALF, bowl1: bowl1, bowl2: second}
 670 |                     : {op: OpCodes.MOLD_PUSH_HALF_BOWL, mold: second,
 671 |                        bowl: bowl1};
 672 |                 break;
 673 |             }
 674 |             case "pour contents of": {
 675 |                 const bowl1 = this.bowl();
 676 |                 this.expect_keyword("into");
 677 |                 const [kind, second] = this.bowl_or_mold();
 678 |                 ret = kind == "bowl" ?
 679 |                     {op: OpCodes.TRANSFER_ALL, bowl1: bowl1, bowl2: second}
 680 |                     : {op: OpCodes.MOLD_PUSH_BOWL, mold: second, bowl: bowl1};
 681 |                 break;
 682 |             }
 683 |             case "proceed to step": {
 684 |                 const num = this.expect(TokenKind.NUMBER);
 685 |                 if (num.value <= step_num) {
 686 |                     this.complain(num, "must be a future step number");
 687 |                 }
 688 |                 ret = {op: OpCodes.GO_TO, step: num.value, loc: num.loc};
 689 |                 break;
 690 |             }
 691 |             case "go back to step": {
 692 |                 const num = this.expect(TokenKind.NUMBER);
 693 |                 if (num.value >= step_num || num.value <= 0) {
 694 |                     this.complain(num, "must be a previous step number");
 695 |                 }
 696 |                 ret = {op: OpCodes.GO_TO, step: num.value};
 697 |                 break;
 698 |             }
 699 |             case "place": {
 700 |                 const bowl = this.bowl();
 701 |                 this.expect_keyword("in the oven and bake at");
 702 |                 const temp_tok = this.expect(TokenKind.TEMPERATURE);
 703 |                 const t = temp_tok.value;
 704 |                 if (!valid_temperatures.includes(t)) {
 705 |                     this.complain(temp_tok, `our oven can't be set to ${t}!`);
 706 |                 }
 707 |                 ret = {op: OpCodes.BAKE, bowl: bowl, temperature: t};
 708 |                 break;
 709 |             }
 710 |             case "serves": {
 711 |                 const num = this.positive_int();
 712 |                 ret = {op: OpCodes.SERVES, num: num};
 713 |                 break;
 714 |             }
 715 |             case "remove a layer from": {
 716 |                 const mold = this.mold();
 717 |                 const second = this.expect(
 718 |                     TokenKind.NEW_LINE, TokenKind.KEY_PHRASE
 719 |                 );
 720 |                 if (second.kind == TokenKind.NEW_LINE) {
 721 |                     consume_new_line = false;
 722 |                     ret = {op: OpCodes.MOLD_POP, mold: mold};
 723 |                     break;
 724 |                 }
 725 |                 if (second.value != "and dump into") {
 726 |                     this.complain(
 727 |                         second, `keyword "${second.value}" can't be used here`
 728 |                     );
 729 |                 }
 730 |                 const bowl = this.bowl();
 731 |                 ret = {op: OpCodes.MOLD_POP_AND_STORE, mold: mold, bowl: bowl};
 732 |                 break;
 733 |             }
 734 |             case "microwave": {
 735 |                 const mold = this.mold();
 736 |                 const second = this.expect(
 737 |                     TokenKind.NEW_LINE, TokenKind.KEY_PHRASE
 738 |                 );
 739 |                 let op;
 740 |                 if (second.kind == TokenKind.NEW_LINE) {
 741 |                     consume_new_line = false;
 742 |                     op = OpCodes.MICROWAVE;
 743 |                 }
 744 |                 else if (second.value == "in grill mode") {
 745 |                     op = OpCodes.MICROWAVE_GRILL;
 746 |                 }
 747 |                 else {
 748 |                     this.complain(
 749 |                         second, `keyword "${second.value}" can't be used here`
 750 |                     );
 751 |                 }
 752 |                 ret = {op, mold};
 753 |                 break;
 754 |             }
 755 |             case "stir the mixture in": {
 756 |                 const mold = this.mold();
 757 |                 this.expect_keyword("until smooth");
 758 |                 ret = {op: OpCodes.STIR_UNTIL_SMOOTH, mold};
 759 |                 break;
 760 |             }
 761 |             case "sift the mixture in": {
 762 |                 ret = {op: OpCodes.SIFT, mold: this.mold()};
 763 |                 break;
 764 |             }
 765 |             case "whip the mixture in": {
 766 |                 ret = {op: OpCodes.WHIP, mold: this.mold()};
 767 |                 break;
 768 |             }
 769 |             case "bring the mixture in": {
 770 |                 const mold = this.mold();
 771 |                 this.expect_keyword("to a boil");
 772 |                 ret = {op: OpCodes.BOIL, mold};
 773 |                 break;
 774 |             }
 775 |             case "serve with": {
 776 |                 const recipe = this.expect(TokenKind.PHRASE);
 777 |                 ret = {
 778 |                     op: OpCodes.SERVE_WITH, recipe: recipe.value,
 779 |                     loc: recipe.loc
 780 |                 };
 781 |                 break;
 782 |             }
 783 |             default: {
 784 |                 this.complain(tok, `unknown step "${tok.value}"`);
 785 |             }
 786 |         }
 787 |         if (consume_new_line) {
 788 |             this.expect(TokenKind.NEW_LINE);
 789 |         }
 790 |         return ret;
 791 |     }
 792 | }
 793 | 
 794 | function parse(tokens) {
 795 |     return new Parser(tokens).program();
 796 | }
 797 | 
 798 | /*--- The semantic analyzer! ---*/
 799 | 
 800 | function semantic_analyze(program) {
 801 |     // Make sure "Muffin" recipe exists
 802 |     if (!program.recipes.has("Muffin")) {
 803 |         throw new CompileError('entry recipe "Muffin" is not found', null);
 804 |     }
 805 |     for (const recipe of program.recipes.values()) {
 806 |         for (const step of recipe.steps) {
 807 |             const c = step.content;
 808 |             // Make sure GO_TO targets are good
 809 |             if (c.op == OpCodes.GO_TO && c.step > recipe.steps.length) {
 810 |                 throw new CompileError(
 811 |                     `step number ${c.step} is too big`, c.loc
 812 |                 );
 813 |             }
 814 |             // Make sure SERVE_WITH recipe is defined
 815 |             if (c.op == OpCodes.SERVE_WITH && !program.recipes.has(c.recipe)) {
 816 |                 throw new CompileError(
 817 |                     `recipe "${c.recipe}" is not found`, c.loc
 818 |                 );
 819 |             }
 820 |         }
 821 |     }
 822 | }
 823 | 
 824 | /*--- The code generator! ---*/
 825 | 
 826 | export class CodeGenConfig {
 827 |     constructor(owner) {
 828 |         this.owner = owner;
 829 |         this.loop_prolog = "";
 830 |         this.loop_epilog = "";
 831 |         this.func_prolog = "";
 832 |         this.teardown = "";
 833 |         // Await works iff this is set:
 834 |         this.asynchronous = false;
 835 |     }
 836 |     handle_error(error) {
 837 |         throw new Error("not implemented");
 838 |     }
 839 |     handle_unexpected_error(error) {
 840 |         throw new Error("not implemented");
 841 |     }
 842 |     handle_exit(code) {
 843 |         throw new Error("not implemented");
 844 |     }
 845 |     handle_println(object) {
 846 |         throw new Error("not implemented");
 847 |     }
 848 |     handle_print(object) {
 849 |         throw new Error("not implemented");
 850 |     }
 851 |     at_last(code) {
 852 |         return code;
 853 |     }
 854 | }
 855 | 
 856 | export class NodeConfig extends CodeGenConfig {
 857 |     constructor(owner) {
 858 |         super(owner);
 859 |         this.readline_needed = false;
 860 |         // When readline is used this must be set:
 861 |         this.asynchronous = true;
 862 |     }
 863 |     handle_error(error) {
 864 |         return `console.error("Muffin error: " + ${error});`;
 865 |     }
 866 |     handle_unexpected_error(error) {
 867 |         return `console.error(\`Unexpected error: \${${error}}\`);`;
 868 |     }
 869 |     handle_exit(code) {
 870 |         return `process.exit(${code});`;
 871 |     }
 872 |     handle_println(object) {
 873 |         return `console.log(${object});`;
 874 |     }
 875 |     handle_print(object) {
 876 |         return `process.stdout.write(String(${object}));`;
 877 |     }
 878 |     handle_read_line() {
 879 |         this.readline_needed = true;
 880 |         this.teardown = "rl.close();";
 881 |         return `await LL()`;
 882 |     }
 883 |     at_last(code) {
 884 |         if (this.readline_needed) {
 885 |             return (
 886 |                 "import {createInterface} from 'node:readline';"
 887 |                 + "const rl = createInterface({input: process.stdin});"
 888 |                 + "function LL() {return new Promise((r) => "
 889 |                 + "rl.question('', r));}"
 890 |                 + code
 891 |             );
 892 |         }
 893 |         return code;
 894 |     }
 895 | }
 896 | 
 897 | class CodeGenerator {
 898 |     constructor(program, config_cls) {
 899 |         this.recipe_ids = new Map();
 900 |         this.recipe_resolve = [];
 901 |         this.bowl_kind_ids = new Map();
 902 |         this.mold_kind_ids = new Map();
 903 |         this.error_message_ids = new Map();
 904 |         this.error_message_resolve = [];
 905 |         this.config = new config_cls(this);
 906 |         this.n_func = "f";
 907 |         this.n_bowls = "b";
 908 |         this.n_molds = "m";
 909 |         this.n_kind = "k";
 910 |         this.n_ip = "i";
 911 |         this.n_new_ip = "I";
 912 |         this.n_err = "e";
 913 |         this.n_tmp = "t";
 914 |         this.program = program;
 915 |         for (const name of program.recipes.keys()) {
 916 |             this.recipe_ids.set(name, this.recipe_ids.size);
 917 |             this.recipe_resolve.push(name);
 918 |         }
 919 |     }
 920 |     main() {
 921 |         const ret = [
 922 |             `const ${this.n_molds} = {};`,
 923 |         ];
 924 |         for (const [name, recipe] of this.program.recipes.entries()) {
 925 |             this.current_recipe = name;
 926 |             ret.push(
 927 |                 this.config.asynchronous ? "async " : "",
 928 |                 `function ${this.func(name)}() {`,
 929 |                 `const ${this.n_bowls} = {};`,
 930 |                 `let ${this.n_ip} = 1;`,
 931 |                 this.config.func_prolog,
 932 |                 `while (${this.n_ip} <= ${recipe.steps.length}) {`,
 933 |                 `let ${this.n_new_ip} = null;`,
 934 |                 `let ${this.n_tmp};`,
 935 |                 this.config.loop_prolog,
 936 |                 `switch (${this.n_ip}) {`,
 937 |             );
 938 |             this.current_step = 0;
 939 |             for (const step of recipe.steps) {
 940 |                 this.current_step++;
 941 |                 let stmt = this.gen_step(step.content).join("");
 942 |                 if (step.predicate != null) {
 943 |                     stmt = this.gen_predicate(step.predicate, stmt).join("");
 944 |                 }
 945 |                 ret.push(`case ${this.current_step}: ${stmt} break;`);
 946 |             }
 947 |             ret.push(
 948 |                 "}",  // end switch
 949 |                 this.config.loop_epilog,
 950 |                 `if (${this.n_new_ip} == null) {${this.n_ip}++;}`,
 951 |                 `else {${this.n_ip} = ${this.n_new_ip};}`,
 952 |                 "}",  // end while
 953 |                 "return 0;",  // assumed normal exit
 954 |                 "}",  // end function
 955 |             );
 956 |         }
 957 |         const print_error = this.config.handle_error([
 958 |             '`in recipe "${',
 959 |             JSON.stringify(this.recipe_resolve),
 960 |             '[',
 961 |             this.n_err,
 962 |             '[0]]}", step ${',
 963 |             this.n_err,
 964 |             '[1]}: ${',
 965 |             JSON.stringify(this.error_message_resolve),
 966 |             '[',
 967 |             this.n_err,
 968 |             '[2]]}`',
 969 |         ].join(""));
 970 |         ret.push(
 971 |             `try {${this.config.handle_exit(this.call_func("Muffin"))}}`,
 972 |             `catch (${this.n_err}) {`,
 973 |             `if (${this.n_err} instanceof Array) {${print_error}}`,
 974 |             `else {${this.config.handle_unexpected_error(this.n_err)}}`,
 975 |             "}",
 976 |         );
 977 |         if (this.config.teardown) {
 978 |             ret.push(`finally {${this.config.teardown}}`);
 979 |         }
 980 |         return this.config.at_last(ret.join(""));
 981 |     }
 982 |     func(recipe_name) {
 983 |         return this.n_func + this.recipe_ids.get(recipe_name);
 984 |     }
 985 |     call_func(recipe_name) {
 986 |         return (
 987 |             (this.config.asynchronous ? "await " : "")
 988 |             + `${this.func(recipe_name)}()`
 989 |         );
 990 |     }
 991 |     bowl_array(bowl_kind) {
 992 |         let id = this.bowl_kind_ids.get(bowl_kind);
 993 |         if (id == undefined) {
 994 |             id = this.bowl_kind_ids.size;
 995 |             this.bowl_kind_ids.set(bowl_kind, id);
 996 |         }
 997 |         return `${this.n_bowls}.${this.n_kind}${id}`;
 998 |     }
 999 |     mold_array(mold_kind) {
1000 |         let id = this.mold_kind_ids.get(mold_kind);
1001 |         if (id == undefined) {
1002 |             id = this.mold_kind_ids.size;
1003 |             this.mold_kind_ids.set(mold_kind, id);
1004 |         }
1005 |         return `${this.n_molds}.${this.n_kind}${id}`;
1006 |     }
1007 |     acquire_mold_bowl_impl(node, callback, arr_func) {
1008 |         const {kind, id} = node;
1009 |         const arr = this[arr_func](kind);
1010 |         const too_large = `id ${id} too large for "${kind}"`;
1011 |         const not_set_up = `"${kind}" not set up yet`;
1012 |         const item = `${arr}[${id - 1}]`;
1013 |         return (
1014 |             `if (!${arr}) {${this.call_fatal(not_set_up)}}`
1015 |             + (
1016 |                 // No need to check index out of bounds for id 1
1017 |                 id == 1 ? ""
1018 |                 : `else if (${arr}.length < ${id})`
1019 |                 + `{${this.call_fatal(too_large)}}`
1020 |             )
1021 |             + `else {${callback(item)}}`
1022 |         );
1023 |     }
1024 |     acquire_mold(node, cb) {
1025 |         return this.acquire_mold_bowl_impl(node, cb, "mold_array");
1026 |     }
1027 |     acquire_bowl(node, cb) {
1028 |         return this.acquire_mold_bowl_impl(node, cb, "bowl_array");
1029 |     }
1030 |     mold_pop2(node, cb) {
1031 |         return this.acquire_mold(node, (mold) => {
1032 |             const m1 =
1033 |                 "not enough elements in mold to perform this step (2 needed)";
1034 |             const m2 = "top of mold is not a number";
1035 |             const m3 = "second top of mold is not a number";
1036 |             const tos = this.n_tmp + "[0]";
1037 |             const tos1 = this.n_tmp + "[1]";
1038 |             return [
1039 |                 `if (${mold}.length < 2) {${this.call_fatal(m1)}}`,
1040 |                 `${this.n_tmp} = [${mold}.pop()];`,
1041 |                 `if (typeof ${tos} == "string") {${this.call_fatal(m2)}}`,
1042 |                 `${this.n_tmp}.push(${mold}.pop());`,
1043 |                 `if (typeof ${tos1} == "string") {${this.call_fatal(m3)}}`,
1044 |                 cb(mold, tos1, tos),
1045 |             ].join("");
1046 |         });
1047 |     }
1048 |     call_fatal(message) {
1049 |         if (!this.error_message_ids.has(message)) {
1050 |             this.error_message_ids.set(message, this.error_message_ids.size);
1051 |             this.error_message_resolve.push(message);
1052 |         }
1053 |         const msg = [
1054 |             this.recipe_ids.get(this.current_recipe),
1055 |             this.current_step,
1056 |             this.error_message_ids.get(message),
1057 |         ];
1058 |         return `throw ${JSON.stringify(msg)};`;
1059 |     }
1060 |     gen_step(x) {
1061 |         // `x` is step content (an Object with an `op` attribute)
1062 |         let t1;
1063 |         let t2;
1064 |         switch (x.op) {
1065 |         case OpCodes.SET_UP_BOWL:
1066 |             t1 = this.bowl_array(x.bowl_kind);
1067 |             t2 = `bowl kind "${x.bowl_kind}" already set up`;
1068 |             return [
1069 |                 `if (${t1}) {${this.call_fatal(t2)}}`,
1070 |                 `else {${t1} = new Array(${x.num}).fill(0);}`,
1071 |             ];
1072 |         case OpCodes.SET_UP_MOLD:
1073 |             t1 = this.mold_array(x.mold_kind);
1074 |             t2 = `mold kind "${x.mold_kind}" already set up`;
1075 |             return [
1076 |                 `if (${t1}) {${this.call_fatal(t2)}}`,
1077 |                 "else {",
1078 |                 `${t1} = new Array(${x.num});`,
1079 |                 `for (let i = 0; i < ${x.num}; i++) {${t1}[i] = [];}`,
1080 |                 "}",
1081 |             ];
1082 |         case OpCodes.ADD_ING_TO_BOWL:
1083 |             return [
1084 |                 this.acquire_bowl(x.bowl, (b) => `${b} += ${x.ing};`),
1085 |             ];
1086 |         case OpCodes.REMOVE_ING_FROM_BOWL:
1087 |             return [
1088 |                 this.acquire_bowl(
1089 |                     x.bowl, (b) => `${b} -= Math.min(${b}, ${x.ing});`
1090 |                 ),
1091 |             ];
1092 |         case OpCodes.CLEAN_BOWL:
1093 |             return [
1094 |                 this.acquire_bowl(x.bowl, (b) => `${b} = 0;`),
1095 |             ];
1096 |         case OpCodes.ADD_WATER_TO_BOWL:
1097 |             return [
1098 |                 this.acquire_bowl(x.bowl, (b) => `${b} *= ${x.num + 1};`),
1099 |             ];
1100 |         case OpCodes.TRANSFER_HALF:
1101 |             return [
1102 |                 this.acquire_bowl(x.bowl1, (b1) => this.acquire_bowl(
1103 |                     x.bowl2, (b2) =>
1104 |                         `${this.n_tmp} = Math.floor(${b1} / 2);`
1105 |                         + `${b1} -= ${this.n_tmp}; ${b2} += ${this.n_tmp};`
1106 |                 )),
1107 |             ];
1108 |         case OpCodes.TRANSFER_ALL:
1109 |             return [
1110 |                 this.acquire_bowl(x.bowl1, (b1) => this.acquire_bowl(
1111 |                     x.bowl2, (b2) => `${b2} += ${b1}; ${b1} = 0;`
1112 |                 )),
1113 |             ];
1114 |         case OpCodes.GO_TO:
1115 |             return [
1116 |                 `${this.n_new_ip} = ${x.step};`,
1117 |             ]
1118 |         case OpCodes.BAKE:
1119 |             return [this.acquire_bowl(x.bowl, (b) => {
1120 |                 switch (x.temperature) {
1121 |                 case "190C":
1122 |                     return this.config.handle_println(b);
1123 |                 case "425F":
1124 |                     const object = `String.fromCodePoint(${b})`;
1125 |                     return [
1126 |                         `if (${b} >= 0x110000) `,
1127 |                         // TODO log the code point
1128 |                         `{${this.call_fatal("invalid code point")}}`,
1129 |                         `else {${this.config.handle_print(object)}}`,
1130 |                     ].join("");
1131 |                 case "230C": {
1132 |                     const x = this.config.handle_read_line();
1133 |                     const m1 = "input line is not a single integer";
1134 |                     return [
1135 |                         `${this.n_tmp} = parseInt(${x}, 10);`,
1136 |                         `if (isNaN(${this.n_tmp})) {${this.call_fatal(m1)}}`,
1137 |                         `else {${b} = ${this.n_tmp};}`,
1138 |                     ].join("");
1139 |                 }
1140 |                 case "350F": {
1141 |                     const x = this.config.handle_read_line();
1142 |                     const m1 = "input line is not a single character";
1143 |                     return [
1144 |                         `${this.n_tmp} = ${x};`,
1145 |                         `if (${this.n_tmp}.length != 1)`,
1146 |                         `{${this.call_fatal(m1)}}`,
1147 |                         `else {${b} = ${this.n_tmp}.codePointAt(0);}`,
1148 |                     ].join("");
1149 |                 }
1150 |                 }
1151 |             })];
1152 |         case OpCodes.SERVES:
1153 |             return [
1154 |                 `return ${x.num - 1};`,
1155 |             ]
1156 |         case OpCodes.MOLD_PUSH_BOWL:
1157 |             return [
1158 |                 this.acquire_bowl(x.bowl, (b) => this.acquire_mold(
1159 |                     x.mold, (m) => `${m}.push(${b}); ${b} = 0;`
1160 |                 )),
1161 |             ]
1162 |         case OpCodes.MOLD_PUSH_HALF_BOWL:
1163 |             return [
1164 |                 this.acquire_bowl(x.bowl, (b) => this.acquire_mold(
1165 |                     x.mold, (m) => (
1166 |                         `${this.n_tmp} = Math.floor(${b} / 2);`
1167 |                         + `${b} -= ${this.n_tmp}; ${m}.push(${this.n_tmp});`
1168 |                     )
1169 |                 )),
1170 |             ]
1171 |         case OpCodes.MOLD_POP:
1172 |             t1 = "cannot pop from empty mold";
1173 |             return [
1174 |                 this.acquire_mold(x.mold, (m) =>
1175 |                     `if (${m}.pop() == undefined) {${this.call_fatal(t1)}}`
1176 |                 ),
1177 |             ]
1178 |         case OpCodes.MOLD_POP_AND_STORE:
1179 |             t1 = "cannot pop from empty mold";
1180 |             t2 = "cannot store string value into bowl";
1181 |             return [
1182 |                 this.acquire_mold(x.mold, (m) => this.acquire_bowl(
1183 |                     x.bowl, (b) => `${this.n_tmp} = ${m}.pop();`
1184 |                         + `if (${this.n_tmp} == undefined)`
1185 |                         + `{${this.call_fatal(t1)}}`
1186 |                         + `else if (typeof ${this.n_tmp} == "string")`
1187 |                         + `{${this.call_fatal(t2)}}`
1188 |                         + `else {${b} += ${this.n_tmp};}`
1189 |                 )),
1190 |             ]
1191 |         case OpCodes.MICROWAVE:
1192 |         case OpCodes.MICROWAVE_GRILL:
1193 |             t1 = "cannot microwave empty mold";
1194 |             t2 = x.op == OpCodes.MICROWAVE ? "handle_println" : "handle_print";
1195 |             return [
1196 |                 this.acquire_mold(x.mold, (m) => {
1197 |                     const object = `${m}[${m}.length - 1]`;
1198 |                     return (
1199 |                         `if (!${m}.length) {${this.call_fatal(t1)}}`
1200 |                         + `else {${this.config[t2](object)}}`
1201 |                     );
1202 |                 }),
1203 |             ]
1204 |         case OpCodes.MOLD_PUSH_ING:
1205 |             return [
1206 |                 this.acquire_mold(x.mold, (m) =>
1207 |                     `${m}.push(${JSON.stringify(x.ing)});`
1208 |                 ),
1209 |             ]
1210 |         case OpCodes.SERVE_WITH:
1211 |             return [
1212 |                 `${this.call_func(x.recipe)};`
1213 |             ]
1214 |         case OpCodes.STIR_UNTIL_SMOOTH:
1215 |             return [this.mold_pop2(x.mold, (mold, lhs, rhs) => (
1216 |                 `${mold}.push(Math.floor(Math.random()*`
1217 |                 + `(${rhs}-${lhs}+1))+${lhs});`
1218 |             ))];
1219 |         case OpCodes.SIFT:
1220 |             return [this.mold_pop2(x.mold, (mold, lhs, rhs) => (
1221 |                 `${mold}.push(Math.floor(${lhs}/${rhs}));`
1222 |             ))];
1223 |         case OpCodes.WHIP:
1224 |             return [this.mold_pop2(x.mold, (mold, lhs, rhs) => (
1225 |                 `${mold}.push(${lhs}*${rhs});`
1226 |             ))];
1227 |         case OpCodes.BOIL:
1228 |             return [this.mold_pop2(x.mold, (mold, lhs, rhs) => (
1229 |                 `${mold}.push(${lhs}-Math.min(${lhs}, ${rhs}));`
1230 |             ))];
1231 |         default:
1232 |             throw new Error(`Op code ${x.op} not supported yet`);
1233 |         }
1234 |     }
1235 |     gen_predicate(x, inner) {
1236 |         // `x` is predicate (an Object with an `op` attribute)
1237 |         // `inner` is code to execute if `x` is true (a string)
1238 |         switch (x.op) {
1239 |         case PredicateKind.MOLD_IS_EMPTY:
1240 |             return [
1241 |                 this.acquire_mold(x.mold, (m) =>
1242 |                     `if (!${m}.length) {${inner}}`
1243 |                 ),
1244 |             ]
1245 |         case PredicateKind.MOLD_NOT_EMPTY:
1246 |             return [
1247 |                 this.acquire_mold(x.mold, (m) =>
1248 |                     `if (${m}.length) {${inner}}`
1249 |                 ),
1250 |             ]
1251 |         case PredicateKind.BOWL_IS_EMPTY:
1252 |             return [
1253 |                 this.acquire_bowl(x.bowl, (m) => `if (!${m}) {${inner}}`),
1254 |             ]
1255 |         case PredicateKind.BOWL_NOT_EMPTY:
1256 |             return [
1257 |                 this.acquire_bowl(x.bowl, (m) => `if (${m}) {${inner}}`),
1258 |             ]
1259 |         default:
1260 |             throw new Error(`Predicate code ${x.op} not supported yet`);
1261 |         }
1262 |     }
1263 | }
1264 | 
1265 | function code_gen(program, config_cls) {
1266 |     return new CodeGenerator(program, config_cls).main();
1267 | }
1268 | 
1269 | /*--- Everything combined! ---*/
1270 | 
1271 | export function compile(code, config_cls) {
1272 |     /**
1273 |      * @param {string} code The Muffin code to compile.
1274 |      * @param {typeof CodeGenConfig} config_cls
1275 |      * @returns {string} The generated JavaScript code.
1276 |      * @throws {CompileError}
1277 |      */
1278 |     const program = parse(tokenize(code));
1279 |     semantic_analyze(program);
1280 |     return code_gen(program, config_cls);
1281 | }
1282 | 


--------------------------------------------------------------------------------