@live-codes/browser-compilers 0.4.10 → 0.4.14

package/dist/svgbob-wasm/svgbob-wasm.js

@@ -0,0 +1,119 @@
+export const svgbobWasm = async (wasmUrl) => {
+  var svgbob_wasm_bg_default =
+    wasmUrl || 'https://cdn.jsdelivr.net/npm/svgbob-wasm/svgbob_wasm_bg.wasm';
+
+  var imports = {};
+  async function loadWasm(module3, imports2) {
+    if (typeof module3 === 'string') {
+      const moduleRequest = await fetch(module3);
+      if (typeof WebAssembly.instantiateStreaming === 'function') {
+        try {
+          return await WebAssembly.instantiateStreaming(moduleRequest, imports2);
+        } catch (e) {
+          if (moduleRequest.headers.get('Content-Type') != 'application/wasm') {
+            console.warn(e);
+          } else {
+            throw e;
+          }
+        }
+      }
+      module3 = await moduleRequest.arrayBuffer();
+    }
+    return await WebAssembly.instantiate(module3, imports2);
+  }
+  var { instance, module: module2 } = await loadWasm(svgbob_wasm_bg_default, imports);
+  var memory = instance.exports.memory;
+  var convert_string = instance.exports.convert_string;
+  var __wbindgen_export_0 = instance.exports.__wbindgen_export_0;
+  var __wbindgen_malloc = instance.exports.__wbindgen_malloc;
+  var __wbindgen_realloc = instance.exports.__wbindgen_realloc;
+  var __wbindgen_free = instance.exports.__wbindgen_free;
+
+  var WASM_VECTOR_LEN = 0;
+  var cachegetUint8Memory0 = null;
+  function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== memory.buffer) {
+      cachegetUint8Memory0 = new Uint8Array(memory.buffer);
+    }
+    return cachegetUint8Memory0;
+  }
+  var lTextEncoder =
+    typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
+  var cachedTextEncoder = new lTextEncoder('utf-8');
+  var encodeString =
+    typeof cachedTextEncoder.encodeInto === 'function'
+      ? function (arg, view) {
+          return cachedTextEncoder.encodeInto(arg, view);
+        }
+      : function (arg, view) {
+          const buf = cachedTextEncoder.encode(arg);
+          view.set(buf);
+          return {
+            read: arg.length,
+            written: buf.length,
+          };
+        };
+  function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === void 0) {
+      const buf = cachedTextEncoder.encode(arg);
+      const ptr2 = malloc(buf.length);
+      getUint8Memory0()
+        .subarray(ptr2, ptr2 + buf.length)
+        .set(buf);
+      WASM_VECTOR_LEN = buf.length;
+      return ptr2;
+    }
+    let len = arg.length;
+    let ptr = malloc(len);
+    const mem = getUint8Memory0();
+    let offset = 0;
+    for (; offset < len; offset++) {
+      const code = arg.charCodeAt(offset);
+      if (code > 127) break;
+      mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+      if (offset !== 0) {
+        arg = arg.slice(offset);
+      }
+      ptr = realloc(ptr, len, (len = offset + arg.length * 3));
+      const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+      const ret = encodeString(arg, view);
+      offset += ret.written;
+    }
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+  }
+  var cachegetInt32Memory0 = null;
+  function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== memory.buffer) {
+      cachegetInt32Memory0 = new Int32Array(memory.buffer);
+    }
+    return cachegetInt32Memory0;
+  }
+  var lTextDecoder =
+    typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+  var cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+  cachedTextDecoder.decode();
+  function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+  }
+  function convert_string2(data) {
+    try {
+      const retptr = __wbindgen_export_0.value - 16;
+      __wbindgen_export_0.value = retptr;
+      var ptr0 = passStringToWasm0(data, __wbindgen_malloc, __wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      convert_string(retptr, ptr0, len0);
+      var r0 = getInt32Memory0()[retptr / 4 + 0];
+      var r1 = getInt32Memory0()[retptr / 4 + 1];
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      __wbindgen_export_0.value += 16;
+      __wbindgen_free(r0, r1);
+    }
+  }
+  return {
+    convert_string: convert_string2,
+  };
+};

package/dist/turbopascal/turbopascal.js

@@ -1,96 +1,85 @@
+// @ts-nocheck
 // based on https://github.com/MikeRalphson/turbopascal/blob/master/tpc.js
 const turbopascal = {
-  compiler: new Promise((resolve) => {
-    requirejs.config({
-      baseUrl: 'https://cdn.jsdelivr.net/npm/turbopascal@1.0.3',
-      paths: {
-        underscore: 'https://cdn.jsdelivr.net/npm/underscore@1.13.2/underscore-umd.min',
-      },
-    });
+  createCompiler: (options = {}) =>
+    new Promise((resolve) => {
+      const inputCallback =
+        options.inputCallback ||
+        ((callback) => {
+          const input = window.prompt('please supply the input');
+          callback(input);
+        });
+      const outputCallback = options.outputCallback || console.log;
+      const errorCallback = options.errorCallback || console.warn;
 
-    require([
-      'Stream',
-      'Lexer',
-      'CommentStripper',
-      'Parser',
-      'PascalError',
-      'Compiler',
-      'Machine',
-      'SymbolTable',
-    ], function (
-      Stream,
-      Lexer,
-      CommentStripper,
-      Parser,
-      PascalError,
-      Compiler,
-      Machine,
-      SymbolTable,
-    ) {
-      function compile(source, run, DEBUG_TRACE) {
-        let self = this;
+      requirejs.config({
+        baseUrl: 'https://cdn.jsdelivr.net/npm/turbopascal@1.0.3',
+        paths: {
+          underscore: 'https://cdn.jsdelivr.net/npm/underscore@1.13.2/underscore-umd.min',
+        },
+      });
 
-        if (!source) {
-          return;
-        }
-
-        let stream = new Stream(source);
-        let lexer = new CommentStripper(new Lexer(stream));
-        let parser = new Parser(lexer);
+      require([
+        'Stream',
+        'Lexer',
+        'CommentStripper',
+        'Parser',
+        'Compiler',
+        'Machine',
+        'SymbolTable',
+      ], function (Stream, Lexer, CommentStripper, Parser, Compiler, Machine, SymbolTable) {
+        function compile(source, run, DEBUG_TRACE) {
+          let result = { parsed: false, compiled: false };
+          if (!source) return result;
 
-        let result = { parsed: false, compiled: false };
+          let stream = new Stream(source);
+          let lexer = new CommentStripper(new Lexer(stream));
+          let parser = new Parser(lexer);
 
-        try {
-          // Create the symbol table of built-in constants, functions, and procedures.
-          let builtinSymbolTable = SymbolTable.makeBuiltinSymbolTable();
+          try {
+            // Create the symbol table of built-in constants, functions, and procedures.
+            let builtinSymbolTable = SymbolTable.makeBuiltinSymbolTable();
 
-          // Parse the program into a parse tree. Create the symbol table as we go.
-          let root = parser.parse(builtinSymbolTable);
-          result.tree = root.print('');
-          result.parsed = true;
+            // Parse the program into a parse tree. Create the symbol table as we go.
+            let root = parser.parse(builtinSymbolTable);
+            result.tree = root.print('');
+            result.parsed = true;
 
-          // Compile to bytecode.
-          let compiler = new Compiler();
-          let bytecode = compiler.compile(root);
-          result.compiled = true;
-          result.bytecode = bytecode;
-          result.pSrc = bytecode.print();
+            // Compile to bytecode.
+            let compiler = new Compiler();
+            let bytecode = compiler.compile(root);
+            result.compiled = true;
+            result.bytecode = bytecode;
+            result.pSrc = bytecode.print();
 
-          if (run) {
-            // Execute the bytecode.
-            let machine = new Machine(bytecode, this.keyboard);
-            if (DEBUG_TRACE) {
-              machine.setDebugCallback(function (state) {
-                $state.append(state + '\\n');
+            if (run) {
+              // Execute the bytecode.
+              let machine = new Machine(bytecode, this.keyboard);
+              if (DEBUG_TRACE) {
+                machine.setDebugCallback(function (state) {
+                  $state.append(state + '\\n');
+                });
+              }
+              machine.setFinishCallback(function (runningTime) {});
+              machine.setOutputCallback(function (line) {
+                outputCallback(line);
               });
-            }
-            machine.setFinishCallback(function (runningTime) {});
-            machine.setOutputCallback(function (line) {
-              console.log(line);
-            });
-            machine.setOutChCallback(function (line) {
-              console.log(line);
-            });
-            machine.setInputCallback(function (callback) {
-              self.screen.addCursor();
-              self._setInputMode(INPUT_STRING, function (line) {
-                self._setInputMode(INPUT_RUNNING);
-                callback(line);
+              machine.setOutChCallback(function (line) {
+                outputCallback(line);
               });
-            });
-            machine.run();
-          }
-        } catch (e) {
-          console.warn(e.message);
-          // Print parsing errors.
-          if (e instanceof PascalError) {
-            console.warn(e.getMessage());
+              machine.setInputCallback(function (callback) {
+                inputCallback(callback);
+              });
+              machine.run();
+            }
+          } catch (e) {
+            // Print errors.
+            const msg = e.getMessage() || e.message || e;
+            errorCallback(msg);
           }
-          console.warn(e.stack);
+          return result;
         }
-        return result;
-      }
-      resolve(compile);
-    });
-  }),
+        resolve(compile);
+      });
+    }),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-codes/browser-compilers",
-  "version": "0.4.10",
+  "version": "0.4.14",
   "description": "Compilers that run in the browser, for use in livecodes.io",
   "author": "Hatem Hosny",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "https://github.com/live-codes/browser-compilers"
   },
   "scripts": {
-    "start": "live-server dist --cors",
+    "start": "live-server dist --port=8081 --no-browser --cors",
     "build": "run-s clean build:vendors copy:types",
     "build:vendors": "node ./scripts/vendors.js",
     "copy:types": "recursive-copy vendor_modules/types dist/types",
@@ -39,6 +39,7 @@
     "react": "17.0.2",
     "react-dom": "17.0.2",
     "react-native-web": "0.17.5",
+    "sass": "1.49.7",
     "svelte": "3.44.1",
     "windicss": "3.2.1"
   },
@@ -51,7 +52,6 @@
     "autoprefixer": "10.4.0",
     "cz-conventional-changelog": "3.2.0",
     "esbuild": "0.11.12",
-    "esbuild-plugin-replace": "1.0.6",
     "eslint": "7.32.0",
     "eslint-config-prettier": "6.11.0",
     "eslint-plugin-import": "2.20.2",

package/scripts/vendors.js

@@ -64,6 +64,28 @@ entryFiles.forEach(async (file) => {
   await parcelBundler.bundle();
 });
 
+// sass
+fs.readFile(path.resolve('node_modules/sass/sass.dart.js'), 'utf8', function (err, data) {
+  if (err) return console.log(err);
+
+  var result = data.replace(
+    'var self = Object.create(dartNodePreambleSelf);',
+    'var self = window;',
+  );
+
+  fs.writeFile(path.resolve('node_modules/sass/sass.dart.js'), result, 'utf8', function (err) {
+    if (err) return console.log(err);
+
+    esbuild.build({
+      ...baseOptions,
+      entryPoints: ['vendor_modules/imports/sass.ts'],
+      outfile: 'dist/sass/sass.js',
+      globalName: 'sass',
+      plugins: nodePolyfills,
+    });
+  });
+});
+
 // Less
 esbuild.buildSync({
   ...baseOptions,
@@ -238,3 +260,21 @@ fs.copyFileSync(
   path.resolve(vendor_modules_src + '/turbopascal/turbopascal.js'),
   path.resolve(targetDir + '/turbopascal/turbopascal.js'),
 );
+
+// gnuplot
+mkdirp(targetDir + '/gnuplot');
+fs.copyFileSync(
+  path.resolve(vendor_modules_src + '/gnuplot-JS/www/gnuplot.js'),
+  path.resolve(targetDir + '/gnuplot/gnuplot.js'),
+);
+fs.copyFileSync(
+  path.resolve(vendor_modules_src + '/gnuplot-JS/www/gnuplot_api.js'),
+  path.resolve(targetDir + '/gnuplot/gnuplot_api.js'),
+);
+
+// svgbob-wasm
+mkdirp(targetDir + '/svgbob-wasm');
+fs.copyFileSync(
+  path.resolve(vendor_modules_src + '/svgbob-wasm/svgbob-wasm.js'),
+  path.resolve(targetDir + '/svgbob-wasm/svgbob-wasm.js'),
+);

package/vendor-licenses.md

@@ -10,6 +10,10 @@ clientside-haml-js: [MIT License](https://github.com/uglyog/clientside-haml-js/b
 
 CoffeeScript: [MIT License](https://github.com/jashkenas/coffeescript/tree/07f644c39223e016aceedd2cd71b5941579b5659)
 
+dart-sass: [MIT License](https://github.com/sass/dart-sass/blob/e3bf3eb3a3a8708877a86a08c7e3bee92160ac1f/LICENSE)
+
+gnuplot-JS: [MIT License](https://github.com/chhu/gnuplot-JS/blob/62a3c8488ad00c97807ba48ae75738ca3af607fe/LICENSE)
+
 JSCPP: [MIT License](https://github.com/felixhao28/JSCPP/blob/befbd6b48666007151c259c5dd291ab028ad4c04/LICENSE)
 
 Less: [Apache License 2.0](https://github.com/less/less.js/blob/870f9b2d8136bfbcdc9e1293bb0def51b54f9276/LICENSE)
@@ -46,6 +50,10 @@ Stylus: [MIT License](https://github.com/stylus/stylus/blob/59bc665db295981d4e3f
 
 Svelte: [MIT License](https://github.com/sveltejs/svelte/blob/dafbdc286eef3de2243088a9a826e6899e20465c/LICENSE)
 
+svgbob: [Apache License 2.0](https://github.com/ivanceras/svgbob/blob/277f28b337a2d00a61cf342247060cf5fbf88d50/LICENSE)
+
+svgbob-wasm: [Apache License 2.0](https://github.com/agoose77/svgbob-wasm/blob/45e280096ee7f7a07981de2ce95aba343bc94123/LICENSE_APACHE)
+
 turbopascal: [BSD 2-Clause License](https://github.com/MikeRalphson/turbopascal/blob/cfcc5ee6d93f32664bb6127aa751c68841ca5c1d/LICENSE)
 
 wacl: [BSD 3-Clause License](https://github.com/ecky-l/wacl/blob/9daacabb0102a9986f33263261350edfeebdd83b/LICENSE)

package/vendor_modules/imports/sass.ts

@@ -0,0 +1,16 @@
+import sass from 'sass';
+
+window.process = {
+  ...window.process,
+  stdout: {
+    write: (...data) => console.log(...data),
+    isTTY: false,
+  },
+  stderr: {
+    write: (...data) => console.warn(...data),
+  },
+  env: {},
+};
+
+export const compileString = sass.compileString;
+export const compileStringAsync = sass.compileStringAsync;

package/vendor_modules/src/gnuplot-JS/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Christian Huettig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor_modules/src/gnuplot-JS/README

@@ -0,0 +1,55 @@
+Portable JS Gnuplot
+*******************
+
+This is the result of compiling gnuplot with emscripten, combined with an API so it is usable straight out of the box in your browser. 
+The www directory contains the necessary files and a compiled version of gnuplot 4.6.3. The gnuplot-4.6.3 directory contains everything to 
+build the gnuplot sources with emscripten. 
+
+How to compile gnuplot
+**********************
+
+- Install llvm / emscripten, follow instructions at http://emscripten.org
+- Download the gnuplot-4.6.3.tar.gz sources at http://gnuplot.info and untar.
+- Copy the contents of this repo's gnuplot-4.6.3 into the folder where you unpacked the sources (should be the same name).
+- [optional] adjust src/term.h and remove unneeded terminals to reduce final size
+- [optional] patch src/axis.c with the patch file to fix axis descriptions: cd src;patch <../gnuplot-4.6.3.patch 
+- Run em_make to configure and build, you should have a gnuplot.js in your directory. WAIT at the end! The final step takes long. 
+
+How the API works
+*****************
+
+The gnuplot API (gnuplot_api.js) creates a worker (JS-thread) that loads gnuplot.js and handles all the work. No browser checks are done to check for HTML5 features. 
+The API lets you interact with the worker to "upload" or "download" files. Emscripten uses a mock-up for file I/O, so keep in mind that files are kept in memory as arrays
+and that you need to push / pull any file-content to / from the fake file system within the worker. The API provides some convenience functions for this.
+
+The demo site from the www directory is online at http://gnuplot.respawned.com
+
+A minimal implementation should look like this (untested! see index.html for working version):
+
+<img id="result"/>
+<script src='gnuplot_api.js'></script>
+<script>
+    gnuplot = new Gnuplot('gnuplot.js');
+    //gnuplot.putFile("myData.dat", "1 2 3 4 5 6 7 8 9 0"); // No callback needed here
+    gnuplot.run("my gnuplot script as a string", function(e) {
+	gnuplot.getFile('out.svg', function(e) {
+	    if (!e.content) {
+               alert("Output file out.svg not found!");
+               return;
+           }
+           var img = document.getElementById('result');
+           try {
+				var ab = new Uint8Array(e.content);
+				var blob = new Blob([ab], {"type": "image\/svg+xml"});
+				window.URL = window.URL || window.webkitURL;
+				img.src = window.URL.createObjectURL(blob);
+           } catch (err) { // in case blob / URL missing, fallback to data-uri
+                var rstr = '';
+	            for (var i = 0; i < e.content.length; i++)
+	              rstr += String.fromCharCode(e.content[i]);
+	            img.src = 'data:image\/svg+xml;base64,' + btoa(rstr);
+           }
+       });
+   });
+</script>
+

package/vendor_modules/src/gnuplot-JS/gnuplot-4.6.3/em_make

@@ -0,0 +1,7 @@
+#!/bin/bash
+emconfigure ./configure --without-readline --without-x --disable-h3d-quadtree --disable-wxwidgets
+#emmake make clean
+emmake make
+rm gnuplot.o
+mv src/gnuplot ./gnuplot.o
+em++ -s INVOKE_RUN=0 -O2 -s ASM_JS=1 gnuplot.o -o gnuplot.js --post-js post.js --pre-js pre.js

package/vendor_modules/src/gnuplot-JS/gnuplot-4.6.3/gnuplot-4.6.3.patch

@@ -0,0 +1,13 @@
+--- gnuplot-4.6.3/src/axis.c	2012-11-08 18:13:08.000000000 +0100
++++ gnuplot-4.6.3_mod/src/axis.c	2013-05-11 11:08:08.791587160 +0200
+@@ -467,8 +467,9 @@ copy_or_invent_formatstring(AXIS_INDEX a
+ 	    int precision = (ceil(-log10(fabs(axmax-axmin))));
+ 	    if ((axmin*axmax > 0) && precision > 4)
+ 		sprintf(ticfmt[axis],"%%.%df", (precision>14) ? 14 : precision);
++	     else
++		strcpy(ticfmt[axis], "%g");
+ 	}
+-
+ 	return ticfmt[axis];
+     }
+ 

package/vendor_modules/src/gnuplot-JS/gnuplot-4.6.3/post.js

@@ -0,0 +1,17 @@
+    shouldRunNow = true;
+    self['Runtime'] = Runtime;
+    self['FS'] = FS;
+};
+gnuplot_create();
+// This is to avoid name mangling from closure compilers 
+self['FS'] = FS;
+self['FS']['root'] = FS.root;
+self['FS']['deleteFile'] = FS.deleteFile;
+self['FS']['findObject'] = FS.findObject;
+self['FS']['createDataFile'] = FS.createDataFile;
+self['FS']['getFileContents'] = function(name) {
+    var file = FS.findObject(name);
+    if (!file) return null;
+    return file.contents;
+};
+

package/vendor_modules/src/gnuplot-JS/gnuplot-4.6.3/pre.js

@@ -0,0 +1,62 @@
+self.addEventListener('message', function(e) {
+  var data = e.data;
+  if (!data) return;
+  var cmd = data['cmd'];
+  var transaction = data['transaction'];
+  var name = data['name'];
+  var content = data['content'];
+  var result = {
+    transaction: transaction
+  };
+  switch (cmd) {
+    case 'run':
+      try {
+        shouldRunNow = true;
+        if (content)
+          Module.run(content);
+        else
+          Module.run();
+      } catch(err) {
+        
+        Module.printErr('Exit called, reset state.');
+        gnuplot_create();
+      };
+      result['content'] = 'FINISH';
+      self.postMessage(result);  
+      break;
+      
+    case 'putFile':
+      if (FS.findObject(name))
+        FS.deleteFile(name);
+      var arrc = content;
+      if (typeof(content) == "string")
+        arrc = Module['intArrayFromString'](content, true);
+      FS.createDataFile('/', name, arrc);
+      result['content'] = 'OK';
+      self.postMessage(result);
+      break;
+
+    case 'getFile':
+      var file = FS.findObject(name);
+      result['content'] = file.contents || 0;
+      self.postMessage(result);
+      break;
+
+    default:
+      result['content'] = 'unknown cmd';
+      self.postMessage(result);
+  };
+}, false);
+
+
+var Module = {
+    'noInitialRun': true,
+    print: function(text) {
+        self.postMessage({'transaction': -1, 'content': text});
+    },
+    printErr: function(text) {
+        self.postMessage({'transaction': -2, 'content': text});
+    },
+  
+};
+function gnuplot_create() {