basedpl 0.1.28 → 0.1.32

package/README.md

@@ -1,242 +1,72 @@
-# BasedPL
+# basedpl
 
+This package runs BasedPL (BPL) in a web page. BPL is an array language derived from APL, with ideas from J and BQN. The package holds the BPL interpreter compiled to WebAssembly, a language bar for typing BPL's glyphs, and a TextMate grammar for highlighting BPL code. The [BPL documentation](https://answerdotai.github.io/basedpl/) covers the language. The [playground](https://answerdotai.github.io/basedpl/playground.html) runs BPL in the browser with this package.
 
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+## Load the package
 
-BasedPL, the Based-array Programming Language, is an array language derived from APL, with ideas from J and BQN. Its notation aims to be simple and consistent. Most of this documentation calls it BPL. BPL is written in Rust and comes as a native executable, a Jupyter kernel and a Python API.
+jsDelivr serves every file in the package. An unversioned URL, such as `https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js`, gives the latest release. To keep one release, put its version in the URL: `https://cdn.jsdelivr.net/npm/basedpl@<version>/basedpl_wasm.js`. To install the package instead, run `npm install basedpl`.
 
-LLMs: read [llms.txt](https://answerdotai.github.io/basedpl/llms.txt) first. It is the primary reference index and concise overview.
+## Run BPL
 
-## Install and try it
+```js
+import init, { Session, configure } from 'https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js';
 
-``` sh
-pip install basedpl
-bpl
+await init();
+configure(location.href, message => console.error(message));
+const session = new Session();
+const error = session.run('avg←+/÷≢ ⋄ avg 2 4 9', output => console.log(output.data['text/plain']));
 ```
 
-Each release also has a standalone `bpl` that needs no Python, for macOS on Apple silicon and for Linux on x86-64 and arm64. On a Mac:
+This logs `5`, and `error` is `null`.
 
-``` sh
-curl -Lo bpl https://github.com/AnswerDotAI/basedpl/releases/latest/download/bpl-macos-arm64
-chmod +x bpl
-```
-
-On Linux, download `bpl-linux-x86_64` or `bpl-linux-arm64` instead.
-
-At the prompt, define a mean and apply it:
-
-``` bpl
-avg←+/÷≢
-avg 2 4 9
-```
-
-    5
-
-Use `bpl -e 'avg←+/÷≢ ⋄ avg 2 4 9'` for a shell command. The [command-line guide](https://answerdotai.github.io/basedpl/cli.html) covers source files and pipes.
-
-## Interactive use
-
-In the REPL, type a backtick followed by a glyph name. For example, `` `iota `` becomes `⍳` when you press Tab or type a non-letter. Abbreviations and Alt-key shortcuts are available. `]help +` shows help for `+`. [`•prefs`](https://answerdotai.github.io/basedpl/system-functions.html#prefs) changes display settings, such as boxes and how much of a large array shows. See [REPL](https://answerdotai.github.io/basedpl/repl.html) and the [glyph reference](https://answerdotai.github.io/basedpl/glyphs.html), which lists each glyph’s key.
-
-In Jupyter, select the installed **BasedPL** kernel. Cells share definitions and support completion, Shift-Tab help and interruption. You can also use `%%bpl` cells in a Python notebook. See [Using BPL notebooks](https://answerdotai.github.io/basedpl/notebooks.html).
-
-## New to APL?
-
-APL is a language built around operations on whole arrays and notation for combining functions. Here is a taste of that style in BPL.
-
-Numbers separated by spaces form a vector. Arithmetic applies to every element:
-
-``` bpl
-10+1 2 3
-```
-
-    11 12 13
-
-Operators modify or combine functions. Reduce (`/`) turns addition into summation. `⍳10` generates 0…9:
-
-``` bpl
-+/⍳10
-```
-
-    45
-
-Functions can also be combined without naming their arguments. In `avg←+/÷≢`, sum (`+/`) divided by tally (`≢`) defines the mean:
-
-``` bpl
-avg 1 2 3 4
-```
-
-    2.5
-
-To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨1+⍳50`), count the zeros down each column (`+⌿0=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `1+` turns each position back into its number:
-
-``` bpl
-1+⍸2=+⌿0=|⊗⍨1+⍳50
-```
-
-    2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
-
-[Getting started](https://answerdotai.github.io/basedpl/getting-started.html#example-algorithms) builds a primes function from the same divisor count, step by step, and displays the divisibility matrix along the way.
-
-## What’s distinctive?
-
-For APL users, some key differences are:
-
-- [Based arrays](https://answerdotai.github.io/basedpl/arrays.html), as in BQN: numbers, characters and functions are atoms; enclosure always adds a layer.
-- **Vectors in brackets, and grouping by spaces.** `[a b c]` is a vector, and `a+b × c+d` is `(a+b)×(c+d)`. A run that ends in a function is a train. For example, `+/÷≢ x` is the mean of `x`, and `2×` doubles its argument. `0⌷v` and `v₀` both select the first item of `v`.
-- **Leading-axis broadcasting**, including expansion of length-1 axes, plus string keys and names on axes.
-- **Exact integers and rationals** alongside approximate real and complex numbers.
-- Dfns, trains and operators, with additions such as Under, iteration histories, windows and function arrays.
-
-Positions and axes count from 0, as in BQN and Python. Approximate comparisons use tolerance `1E¯14`. See the [language principles](https://answerdotai.github.io/basedpl/principles.html) for why BPL works this way, the [glyph reference](https://answerdotai.github.io/basedpl/glyphs.html) for Dyalog differences and [Arrays](https://answerdotai.github.io/basedpl/arrays.html) for the array model.
-
-### Numbers
-
-Bare numbers are approximate. Use `ₓ` for exact integers and `r` for exact fractions:
-
-``` bpl
-1r3+1r6
-```
-
-    1ᵣ2
-
-Complex numbers use `j` between real and imaginary parts. Functions such as square root extend into the complex domain:
-
-``` bpl
-√¯4
-```
-
-    0ⱼ2
-
-See [Numbers](https://answerdotai.github.io/basedpl/numbers.html) for conversion and mixed arithmetic.
+- `init()` fetches the module from beside the glue.
+- `configure(base, panic)` sets the URL that relative file reads resolve against, and the function that receives a panic's message. After a panic, the module can't run more code.
+- `session.run(code, output)` runs `code`, then returns `null` or the error. The error is an object with `kind`, `message` and `display`. `display` holds the error as BPL shows it. A session keeps its names from one `run` to the next.
+- `output` receives each output as the program produces it, as `{kind, data}`. `kind` is `"display"` for a displayed value, `"explicit"` for a value assigned to `⎕`, or `"text"` for text written with `"-" •nput`. Display and explicit outputs each end a line. Text output doesn't.
 
-### Array literals and broadcasting
+`data` maps MIME types to text, or to a `Uint8Array` for a binary type:
 
-Write matrix rows directly in an array literal. Leading-axis agreement lets a vector supply one offset per row:
+- `text/plain`: the output as text.
+- `text/html`: markup from element functions.
+- `image/svg+xml`: markup from `•svg` and `•plot`.
+- `image/x-rgba;width=N`: RGBA pixels from `•image`, `N` pixels wide. `new ImageData(new Uint8ClampedArray(bytes.buffer), N)` makes a canvas image from them.
+- `image/png` and `image/jpeg`: encoded images. An animation from `•image` is an animated PNG.
+- `application/x-bpl-canvas+json` and `application/x-bpl-canvas-data`: a canvas from `•canvas`. `canvas.js` is a script whose value is a function that draws it: `(0, eval)(script)(canvas, data['application/x-bpl-canvas+json'], data['application/x-bpl-canvas-data'])`, where `canvas` is a `<canvas>` element.
 
-``` bpl
-m←[1 2 3
-   4 5 6]
-m+10 20
-```
-
-    11 12 13
-    24 25 26
-
-See [array notation](https://answerdotai.github.io/basedpl/glyphs/brackets.html) and [broadcasting](https://answerdotai.github.io/basedpl/evaluation.html#agreement-and-pervasion).
-
-### Keys and named axes
-
-Axes can have names, and positions along them can have string keys. Describe the axes once, then select by key or reduce by axis name:
-
-``` bpl
-axes←["city":["NY" "LA"] "month":["Jan" "Feb" "Mar"]]
-sales←axes:[10 20 30 ⋄ 40 50 60]
-"LA" "Feb"⌷sales
-+/⍠"month" sales
-```
-
-    50
-
-    ["city":2]⍴["NY":60 "LA":150]
-
-Keys and names travel with axes through operations such as transpose. Arithmetic aligns matching names and keys. See [Axis keys](https://answerdotai.github.io/basedpl/keyed.html).
-
-### Function operators
+`run` returns only when the code finishes. To keep the page responsive, run BPL in a Web Worker. The docs' [`worker.js`](https://github.com/AnswerDotAI/basedpl/blob/main/nbs/playground/worker.js) runs BPL in a worker, and [`bpl.js`](https://github.com/AnswerDotAI/basedpl/blob/main/nbs/playground/bpl.js) starts the worker and shows each output on the page.
 
-A vector of counts keeps the history: one state for each count, where count 0 is the initial value. Here, double up to four times:
+## Values and JavaScript functions
 
-``` bpl
-2×⍣(⍳5) 1
-```
-
-    1 2 4 8 16
-
-Under (`⌾`) transforms the argument, applies a function, then reverses the transformation. Scale by ten, floor, and scale back to round down to tenths:
+`session.eval(code)` returns the value of `code` as a JavaScript value, or `undefined` when the code gives no value. A BPL error throws the error object. `session.bind(names)` binds each property of the object `names` as a BPL name. A JavaScript function becomes a BPL function that calls it, with the right argument, or the left then the right. Inside BPL, `•js source` makes such a function from JavaScript source. Values cross as the [`•js`](https://answerdotai.github.io/basedpl/system/js.html) page describes: a number is a number, a string a string and a record an object. Any other array is `{shape, data}`, with `data` a typed array when every item is a number.
 
-``` bpl
-⌊⌾ 10× 1.25 2.78
+```js
+session.bind({ scale: 2, log: x => console.log(x) });
+session.eval('scale×1 2 3');   // {shape: [3], data: Float64Array [2, 4, 6]}
+session.run('log "hi"', () => {});   // logs "hi"
 ```
 
-    1.2 2.7
-
-Explore [iteration and inverses](https://answerdotai.github.io/basedpl/glyphs/power.html), [Under](https://answerdotai.github.io/basedpl/glyphs/under.html), [windows](https://answerdotai.github.io/basedpl/glyphs/windows.html) and [function selection](https://answerdotai.github.io/basedpl/glyphs/agenda.html).
-
-### Mathematical tools
-
-[Primes](https://answerdotai.github.io/basedpl/glyphs/prime.html) and [factorisation](https://answerdotai.github.io/basedpl/glyphs/factor.html) are built in:
-
-``` bpl
-⨸360ₓ
-```
-
-    [2 2 2 3 3 5]ₓ
-
-[Polynomials](https://answerdotai.github.io/basedpl/glyphs/polynomial.html) support coefficients, roots and evaluation. Polynomial functions can be [differentiated](https://answerdotai.github.io/basedpl/glyphs/derivative.html): for f(x) = 1 + 2x + 3x², f′(2) = 14.
-
-``` bpl
-f←[1 2 3]ₓ⌻ ⋄ f∂2ₓ
-```
-
-    14ₓ
-
-[Probability distributions](https://answerdotai.github.io/basedpl/distributions.html) provide sampling, density, CDF and quantiles. Two fair coin tosses give these probabilities for 0, 1 and 2 heads:
-
-``` bpl
-coin←2 0.5 •distribution "binomial"
-coin.density 0 1 2
-```
-
-    0.25 0.5 0.25
-
-[Matrix division](https://answerdotai.github.io/basedpl/glyphs/domino.html) handles linear systems and least squares.
-
-### Data and text
-
-JSON objects become keyed arrays, with dot access to their fields:
-
-``` bpl
-order←•json "{""price"":10.5,""qty"":2}"
-order.price×order.qty
-```
-
-    21
-
-CSV headers likewise name column vectors. [Files, CSV and JSON](https://answerdotai.github.io/basedpl/data.html) covers reading, transforming and writing data. [Regex](https://answerdotai.github.io/basedpl/regex.html) supplies matching, captures and replacement through Rust’s regex engine.
-
-### Drawing
-
-`•plot` draws charts from arrays. Keys label the axes and name the lines. See [Plots](https://answerdotai.github.io/basedpl/plot.html).
-
-``` bpl
-["legend":"end"]•plot sales
-```
-
-![](index_files/figure-commonmark/cell-17-output-1.svg)
-
-Build SVG from element functions and keyed attributes. Notebooks display the picture directly. The same element trees serialize to XML. See [XML and SVG](https://answerdotai.github.io/basedpl/xml.html).
-
-``` bpl
-circle←•element "circle"
-text←•element "text"
-c←["cx":50 "cy":40 "r":25 "fill":"orange"]circle ""
-t←["x":50 "y":85 "text-anchor":"middle"]text "Hello, SVG"
-["width":240 "height":240]•svg [c t]
-```
+## Differences from native BPL
 
-![](index_files/figure-commonmark/cell-18-output-1.svg)
+- `•js` exists only here.
+- `•readdir`, `•metadata`, `•copy`, `•rename`, `•remove`, `•mkdir`, `•path` and `•delay` don't exist. `•nput` writes only to `"-"`.
+- File reads and `•fetch` are synchronous `XMLHttpRequest`s, relative to the URL given to `configure`.
+- `•r` uses JavaScript's `RegExp`, with its syntax and replacement templates.
+- `•date⁻¹` has no `locale` option.
+- Function calls nest at most 380 deep. A deeper call is a `LIMIT` error.
 
-## Python
+## Language bar
 
-BPL functions are Python callables:
+`lb.js` adds a bar of BPL's glyphs to the page. Clicking a glyph types it into the editor used last. In a textarea marked with `data-bpl`, or a Monaco editor whose language is `bpl`, a backtick followed by a glyph's name also types the glyph, as in the BPL REPL. `lb.js` and `input.js` are scripts whose value is a function. The bar needs the glyph rows from `symbols()` and the key layout from `layout.json`:
 
-``` python
-from basedpl import fn
+```js
+import init, { symbols } from 'https://cdn.jsdelivr.net/npm/basedpl/basedpl_wasm.js';
 
-mean = fn('+/÷≢')
-mean([1, 2, 3])
+const text = name => fetch(`https://cdn.jsdelivr.net/npm/basedpl/${name}`).then(r => r.text());
+const [lb, input, layout] = await Promise.all(['lb.js', 'input.js', 'layout.json'].map(text));
+await init();
+(0, eval)(lb)(JSON.parse(symbols()), (0, eval)(input), JSON.parse(layout));
 ```
 
-Arrays have `.py`, `.np` and `.df` conversions for Python values, NumPy and pandas. Functions also have Python names and composition operators. See the [Python tutorial](https://answerdotai.github.io/basedpl/python.html).
+## Highlighting
 
-For other frontends, the [process interfaces](https://answerdotai.github.io/basedpl/processes.html) provide JSON messages and interruptible workers. The [BPL library](https://github.com/AnswerDotAI/basedpl/tree/main/lib) contains more algorithms, codecs, interpreters and puzzles.
+`bpl.tmLanguage.json` is a TextMate grammar for BPL, with the scope name `source.bpl`. Shiki and editors that read TextMate grammars use it to highlight BPL code.

package/basedpl_wasm.js

@@ -9,37 +9,67 @@ export class Session {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_session_free(ptr, 0);
     }
-    constructor() {
-        const ret = wasm.session_new();
-        this.__wbg_ptr = ret;
-        SessionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * Binds each property of `names` as a BPL name, to the BPL value that `basedpl::js` converts it to. A JavaScript function becomes a
+     * BPL function that calls it. Throws when a property's name isn't a BPL name, or its value has no BPL form.
+     * @param {any} names
+     */
+    bind(names) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.session_bind(retptr, this.__wbg_ptr, addBorrowedObject(names));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
     }
     /**
-     * The JSON reply to a JSON request: `{"error": …}`, with `null` when the request succeeds. Each output goes to `output`, as JSON,
-     * while the program runs. The reply has no value: a page shows the output, and a value that holds functions has no JSON form.
-     * @param {string} request
-     * @param {Function} output
-     * @returns {string}
+     * The value of `code` as a JavaScript value, which `basedpl::js` describes, or `undefined` when the code gives no value. A BPL error
+     * throws its error object. The code's outputs are dropped, and `run` shows them.
+     * @param {string} code
+     * @returns {any}
      */
-    request(request, output) {
-        let deferred2_0;
-        let deferred2_1;
+    eval(code) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.session_request(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+            wasm.session_eval(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
+    constructor() {
+        const ret = wasm.session_new();
+        this.__wbg_ptr = ret;
+        SessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Runs `code`, passing each output to `output` as the program produces it, including any result it displays. Returns the error as
+     * an object, or `null`.
+     * @param {string} code
+     * @param {Function} output
+     * @returns {any}
+     */
+    run(code, output) {
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.session_run(this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
 
@@ -77,14 +107,49 @@ export function symbols() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_bigint_get_as_i64_a2383202b9353e4c: function(arg0, arg1) {
+            const v = getObject(arg1);
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_bigint_b123553bed3bb382: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'bigint';
+            return ret;
+        },
         __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
         },
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
             const ret = getObject(arg0) === undefined;
             return ret;
         },
+        __wbg___wbindgen_jsval_eq_02babf21faa37971: function(arg0, arg1) {
+            const ret = getObject(arg0) === getObject(arg1);
+            return ret;
+        },
         __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
             const obj = getObject(arg1);
             const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -102,6 +167,10 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_call_1875a20c43a36133: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
@@ -122,6 +191,14 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).done;
             return ret;
         },
+        __wbg_entries_fb6397112b1de25f: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_eval_2f4f6921d1b0da1a: function() { return handleError(function (arg0, arg1) {
+            const ret = eval(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_exec_a5f4ba02713fbebe: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).exec(getStringFromWasm0(arg1, arg2));
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -134,6 +211,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).fontBoundingBoxDescent;
             return ret;
         },
+        __wbg_from_296ca31f8d0f1c52: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
         __wbg_getAllResponseHeaders_537d007c37d53dba: function() { return handleError(function (arg0, arg1) {
             const ret = getObject(arg1).getAllResponseHeaders();
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -182,6 +263,16 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg_instanceof_BigInt64Array_1a1234d945c1625f: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof BigInt64Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_CanvasRenderingContext2d_769208c72dcbf5e6: function(arg0) {
             let result;
             try {
@@ -202,6 +293,26 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Float32Array_595afb0f28b828c9: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Float32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Float64Array_8a59377f9eec1b8b: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Float64Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_HtmlCanvasElement_0a30c11fbbf41841: function(arg0) {
             let result;
             try {
@@ -212,6 +323,36 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Int16Array_dc79388a406d1748: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Int16Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Int32Array_4b9a86620726269b: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Int32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Int8Array_dead59f83656e45a: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Int8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_OffscreenCanvasRenderingContext2d_957f1a991324c9dc: function(arg0) {
             let result;
             try {
@@ -222,6 +363,46 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Uint16Array_eff85aa31096af44: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint16Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint32Array_53a4facaf04b8a8b: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8ClampedArray_ae70cf3ae1cd285f: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8ClampedArray;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {
             let result;
             try {
@@ -232,14 +413,54 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_length_0acba72356589f9c: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_3035e53132b7a991: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_511b1f84719d3462: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_58572db4c38f3c3e: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
         __wbg_length_7f3c00c40364105e: function(arg0) {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_length_961efae5d4679ef5: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_b5d0ffc9b832763b: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_b5f0008bbf60cf59: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_beff923aab722a55: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
         __wbg_length_d4bdea10311bd9cf: function(arg0) {
             const ret = getObject(arg0).length;
             return ret;
         },
+        __wbg_length_e5fdd54468b9e6ed: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
         __wbg_matchAll_049fec9c830bd9e3: function(arg0, arg1) {
             const ret = getObject(arg0).matchAll(getObject(arg1));
             return addHeapObject(ret);
@@ -264,10 +485,18 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_34e56228080aa9f8: function(arg0) {
             const ret = new Date(getObject(arg0));
             return addHeapObject(ret);
         },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
         __wbg_new_a217df4351db4b9b: function() { return handleError(function (arg0, arg1) {
             const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
             return addHeapObject(ret);
@@ -276,6 +505,34 @@ function __wbg_get_imports() {
             const ret = new XMLHttpRequest();
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_2443ca2017fac0fd: function(arg0, arg1) {
+            const ret = new Int16Array(getArrayI16FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_911f717853b222c7: function(arg0, arg1) {
+            const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_aa8f37bd5e72dcc7: function(arg0, arg1) {
+            const ret = new BigInt64Array(getArrayI64FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_f545fd22ddc142b8: function(arg0, arg1) {
+            const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_no_args_549db978c37d28cc: function(arg0, arg1) {
+            const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_with_base_29cdb449ce79d2d5: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = new URL(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
             return addHeapObject(ret);
@@ -307,13 +564,48 @@ function __wbg_get_imports() {
         __wbg_open_f0c8628338345808: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
         }, arguments); },
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
             const ret = getObject(arg0).performance;
             return addHeapObject(ret);
         },
+        __wbg_prototypesetcall_06eb15da165dee8f: function(arg0, arg1, arg2) {
+            Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_0e2bc23e51b9fbd2: function(arg0, arg1, arg2) {
+            Uint8ClampedArray.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_13adbfb002dee200: function(arg0, arg1, arg2) {
+            Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_2ee09b855e324444: function(arg0, arg1, arg2) {
+            Uint16Array.prototype.set.call(getArrayU16FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_546a6fcbab18189a: function(arg0, arg1, arg2) {
+            Int8Array.prototype.set.call(getArrayI8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_8b03c01e2c0f8066: function(arg0, arg1, arg2) {
+            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_b275ad9519a0a737: function(arg0, arg1, arg2) {
+            BigInt64Array.prototype.set.call(getArrayI64FromWasm0(arg0, arg1), getObject(arg2));
+        },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_prototypesetcall_d49a4fab5ca427bc: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_f8d32a400a944612: function(arg0, arg1, arg2) {
+            Int16Array.prototype.set.call(getArrayI16FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
         __wbg_replace_89a2bb260816315a: function(arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).replace(getObject(arg1), getStringFromWasm0(arg2, arg3));
             return addHeapObject(ret);
@@ -331,6 +623,10 @@ function __wbg_get_imports() {
         __wbg_setRequestHeader_733b74e99bf9b791: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
         __wbg_set_font_1f60a05a2544a2ff: function(arg0, arg1, arg2) {
             getObject(arg0).font = getStringFromWasm0(arg1, arg2);
         },
@@ -373,7 +669,12 @@ function __wbg_get_imports() {
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
@@ -406,17 +707,136 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function dropObject(idx) {
     if (idx < 1028) return;
     heap[idx] = heap_next;
     heap_next = idx;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayI16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayI64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigInt64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayI8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigInt64ArrayMemory0 = null;
+function getBigInt64ArrayMemory0() {
+    if (cachedBigInt64ArrayMemory0 === null || cachedBigInt64ArrayMemory0.byteLength === 0) {
+        cachedBigInt64ArrayMemory0 = new BigInt64Array(wasm.memory.buffer);
+    }
+    return cachedBigInt64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -425,10 +845,66 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+let cachedInt16ArrayMemory0 = null;
+function getInt16ArrayMemory0() {
+    if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
+        cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
+    }
+    return cachedInt16ArrayMemory0;
+}
+
+let cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+
+let cachedInt8ArrayMemory0 = null;
+function getInt8ArrayMemory0() {
+    if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
+        cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
+    }
+    return cachedInt8ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint16ArrayMemory0 = null;
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -493,6 +969,8 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+let stack_pointer = 1024;
+
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);
@@ -533,7 +1011,15 @@ function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
+    cachedBigInt64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedInt16ArrayMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
+    cachedInt8ArrayMemory0 = null;
+    cachedUint16ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     return wasm;
 }

package/bpl.tmLanguage.json

@@ -0,0 +1,108 @@
+{
+  "name": "bpl",
+  "scopeName": "source.bpl",
+  "fileTypes": [
+    "bpl"
+  ],
+  "patterns": [
+    {
+      "begin": "⍝",
+      "beginCaptures": {
+        "0": {
+          "name": "comment.line.bpl"
+        }
+      },
+      "end": "$",
+      "contentName": "comment.line.bpl",
+      "patterns": [],
+      "applyEndPatternLast": true
+    },
+    {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "string.quoted.double.bpl"
+        }
+      },
+      "end": "\"|$",
+      "contentName": "string.quoted.double.bpl",
+      "patterns": [
+        {
+          "match": "\"\"",
+          "name": "string.quoted.double.bpl"
+        }
+      ],
+      "applyEndPatternLast": true,
+      "endCaptures": {
+        "0": {
+          "name": "string.quoted.double.bpl"
+        }
+      }
+    },
+    {
+      "match": "'.?'",
+      "name": "string.quoted.single.bpl"
+    },
+    {
+      "match": "[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*(\\.[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*)*",
+      "name": "source.bpl"
+    },
+    {
+      "match": "•[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*",
+      "name": "support.function.system.bpl"
+    },
+    {
+      "match": "¯?∞|¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?([jJⱼ]¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?|ₓ|[rᵣ]¯?\\d+)?",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "⍬ₓ?",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "\\$[tfn]",
+      "name": "constant.numeric.bpl"
+    },
+    {
+      "match": "\\$[ad]",
+      "name": "string.quoted.double.bpl"
+    },
+    {
+      "begin": "[\\])](?=ₓ)",
+      "beginCaptures": {
+        "0": {
+          "name": "source.bpl"
+        }
+      },
+      "end": "[ₓ]|$",
+      "contentName": "constant.numeric.bpl",
+      "patterns": [],
+      "applyEndPatternLast": true,
+      "endCaptures": {
+        "0": {
+          "name": "constant.numeric.bpl"
+        }
+      }
+    },
+    {
+      "match": "[\\+\\-×÷⌈⌊\\|\\*⍟○π√!∧∨⊼⊽\\~=≠<≤>≥⍳:⍴≢≡,⍪⊂⊃⊆∊∪∩⍋⍒↑↓⌽⊖⍉⊤⊥⍎⍕⌷⌹\\#↕⍭⨸⌻⍸⍷⊢⊣¿]",
+      "name": "support.function.bpl"
+    },
+    {
+      "match": "[¨⍨⊗⌸∂/⌿\\\\⍀⁰¹²³⁴⁵⁶⁷⁸⁹⁻ᵀᵘ]",
+      "name": "keyword.operator.monadic.bpl"
+    },
+    {
+      "match": "[↣⍤∘⍠⍥↢\\.⍣⇄⊘⌾⍚@⌺]",
+      "name": "keyword.operator.dyadic.bpl"
+    },
+    {
+      "match": "[⍺⍵⍶⍹∇⍢]",
+      "name": "variable.parameter.bpl"
+    },
+    {
+      "match": "[←→⎕⋄\\?₀₁₂₃₄₅₆₇₈₉₋]",
+      "name": "keyword.control.bpl"
+    }
+  ]
+}

package/canvas.js

@@ -0,0 +1,8 @@
+// Draws a `•canvas` output on `canvas`. `json` holds the drawing function's JavaScript source, its options and its data. Each typed
+// array in the data is `{$typed, offset, length}`, a view of `bytes`. The native build runs this script from the output's HTML. A page
+// that shows the browser build's outputs calls it with the output's two entries.
+(canvas, json, bytes) => {
+    const view = (_, v) => v?.$typed ? new globalThis[v.$typed](bytes.buffer, bytes.byteOffset + v.offset, v.length) : v;
+    const { source, options, data } = JSON.parse(json, view);
+    (0, eval)(source)(canvas.getContext('2d'), data, options);
+}

package/input.js

@@ -73,8 +73,11 @@
                 if (python && c === '\\') i++;
                 else if (text.startsWith(quote, i)) { i += quote.length - 1; quote = ''; }
             } else if (c === "'" && !python) {
-                if (i + 2 >= text.length) return false;
-                i += 2;
+                if (text.startsWith("''", i) && !text.startsWith("'''", i)) i++;
+                else {
+                    if (i + 2 >= text.length) return false;
+                    i += 2;
+                }
             } else if (c === "'" || c === '"') {
                 quote = python && text.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
                 i += quote.length - 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basedpl",
-  "version": "0.1.28",
+  "version": "0.1.32",
   "description": "BasedPL, the Based-array Programming Language, is an APL-derived array language, borrowing ideas from J and BQN, with an emphasis on simple, consistent notation.",
   "license": "Apache-2.0",
   "repository": {