basedpl 0.1.24

package/README.md

@@ -0,0 +1,242 @@
+# BasedPL
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+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.
+
+LLMs: read [llms.txt](https://answerdotai.github.io/basedpl/llms.txt) first. It is the primary reference index and concise overview.
+
+## Install and try it
+
+``` sh
+pip install basedpl
+bpl
+```
+
+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:
+
+``` 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.
+
+### Array literals and broadcasting
+
+Write matrix rows directly in an array literal. Leading-axis agreement lets a vector supply one offset per row:
+
+``` 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
+
+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:
+
+``` 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:
+
+``` bpl
+⌊⌾ 10× 1.25 2.78
+```
+
+    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]
+```
+
+![](index_files/figure-commonmark/cell-18-output-1.svg)
+
+## Python
+
+BPL functions are Python callables:
+
+``` python
+from basedpl import fn
+
+mean = fn('+/÷≢')
+mean([1, 2, 3])
+```
+
+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).
+
+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.

package/basedpl_wasm.js

@@ -0,0 +1,626 @@
+export class Session {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        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;
+    }
+    /**
+     * 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}
+     */
+    request(request, output) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(request, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.session_request(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(output));
+            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);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Session.prototype[Symbol.dispose] = Session.prototype.free;
+
+/**
+ * Sets the URL that relative paths resolve against, and the function that receives a panic's message.
+ * @param {string} base
+ * @param {Function} panic
+ */
+export function configure(base, panic) {
+    const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.configure(ptr0, len0, addHeapObject(panic));
+}
+
+/**
+ * Every glyph's row, as JSON, for the language bar.
+ * @returns {string}
+ */
+export function symbols() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.symbols(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_construct_2cc135b78387ed16: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.construct(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_createElement_74049073a11f9c31: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_document_9854e03c05fc8834: function(arg0) {
+            const ret = getObject(arg0).document;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_done_b41a1d26cdb37fb6: function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        },
+        __wbg_exec_a5f4ba02713fbebe: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).exec(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_fontBoundingBoxAscent_694ba20be295b1c3: function(arg0) {
+            const ret = getObject(arg0).fontBoundingBoxAscent;
+            return ret;
+        },
+        __wbg_fontBoundingBoxDescent_e0d660bcc3049b29: function(arg0) {
+            const ret = getObject(arg0).fontBoundingBoxDescent;
+            return 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);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_getContext_635e36719cad2623: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getContext_e567868594d2e0c6: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getRandomValues_fc33165644b9e145: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getTime_f5a55efff2585d5d: function(arg0) {
+            const ret = getObject(arg0).getTime();
+            return ret;
+        },
+        __wbg_getTimezoneOffset_2e851fdaecc2dc92: function(arg0) {
+            const ret = getObject(arg0).getTimezoneOffset();
+            return ret;
+        },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_href_221703ee1ed727fc: function(arg0, arg1) {
+            const ret = getObject(arg1).href;
+            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_instanceof_CanvasRenderingContext2d_769208c72dcbf5e6: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof CanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_HtmlCanvasElement_0a30c11fbbf41841: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof HTMLCanvasElement;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_OffscreenCanvasRenderingContext2d_957f1a991324c9dc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Window;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_d4bdea10311bd9cf: 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);
+        },
+        __wbg_measureText_1035b288be51876c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).measureText(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_measureText_57347b02ada3a4ad: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).measureText(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
+        __wbg_new_0_72d020f0c63443d4: function() {
+            const ret = new Date();
+            return addHeapObject(ret);
+        },
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_34e56228080aa9f8: function(arg0) {
+            const ret = new Date(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_a217df4351db4b9b: function() { return handleError(function (arg0, arg1) {
+            const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_d1d1f48568532d74: function() { return handleError(function () {
+            const ret = new XMLHttpRequest();
+            return addHeapObject(ret);
+        }, arguments); },
+        __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);
+        }, arguments); },
+        __wbg_new_with_year_month_day_hr_min_sec_53f4266b8db312e3: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            const ret = new Date(arg0 >>> 0, arg1, arg2, arg3, arg4, arg5);
+            return addHeapObject(ret);
+        },
+        __wbg_next_f4aac29c42af995c: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_normalize_5be7b1fd0a79da76: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).normalize(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_now_7c246bb37a807593: function() { return handleError(function () {
+            const ret = Date.now();
+            return ret;
+        }, arguments); },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_of_20798cb14708764f: function(arg0, arg1) {
+            const ret = Array.of(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __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_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = getObject(arg0).performance;
+            return addHeapObject(ret);
+        },
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_replace_89a2bb260816315a: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).replace(getObject(arg1), getStringFromWasm0(arg2, arg3));
+            return addHeapObject(ret);
+        },
+        __wbg_response_ce3feafb4716c448: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).response;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_send_3b3b20df5e2e7616: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).send(arg1 === 0 ? undefined : getArrayU8FromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_send_9d00bd9d7a2c90b5: function() { return handleError(function (arg0) {
+            getObject(arg0).send();
+        }, arguments); },
+        __wbg_setRequestHeader_733b74e99bf9b791: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_font_1f60a05a2544a2ff: function(arg0, arg1, arg2) {
+            getObject(arg0).font = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_7ef69121e02464cd: function(arg0, arg1, arg2) {
+            getObject(arg0).font = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_responseType_1f631c1316f4c16e: function(arg0, arg1) {
+            getObject(arg0).responseType = __wbindgen_enum_XmlHttpRequestResponseType[arg1];
+        },
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_status_734f92f48f0f8b78: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).status;
+            return ret;
+        }, arguments); },
+        __wbg_value_f3c585ee8f5ba40c: function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        },
+        __wbg_width_e95ad291d52fe17e: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./basedpl_wasm_bg.js": import0,
+    };
+}
+
+const __wbindgen_enum_XmlHttpRequestResponseType = ["", "arraybuffer", "blob", "document", "json", "text"];
+const SessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_session_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('basedpl_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/input.js

@@ -0,0 +1,103 @@
+((symbols, layout) => {
+    // US physical keys, before macOS Option or another layout transforms event.key.
+    const punctuation = {Backquote: '`~', Minus: '-_', Equal: '=+', BracketLeft: '[{', BracketRight: ']}',
+        Backslash: '\\|', Semicolon: ';:', Quote: "'\"", Comma: ',<', Period: '.>', Slash: '/?'};
+    function usKey({code, shiftKey}) {
+        if (/^Key[A-Z]$/.test(code)) return shiftKey ? code.slice(3) : code.slice(3).toLowerCase();
+        if (/^Digit[0-9]$/.test(code)) return shiftKey ? ')!@#$%^&*('[Number(code[5])] : code[5];
+        return punctuation[code]?.[Number(shiftKey)];
+    }
+
+    // Composed input from `layout.json`, with the same rules as the REPL and the macOS layout. `pending` is the dead-key state
+    // that the next key completes.
+    let pending = null;
+    const act = action => typeof action === 'string' ? (pending = null, action) : (pending = action.state, '');
+    // What a key types: `{text, stop}`, where `stop` means the key itself does nothing more, or nothing for an ordinary key.
+    // `option` is whether an Option chord counts here.
+    function press(ev, option) {
+        const key = usKey(ev), plain = !ev.altKey && !ev.ctrlKey && !ev.metaKey;
+        // Native Option can hide the alias character; accept its US physical chord too.
+        const action = option && ev.altKey && !ev.ctrlKey && !ev.metaKey
+            ? layout.alt_aliases[ev.key] ?? layout.option[key] ?? (Object.values(layout.alt_aliases).includes(key) ? key : null) : null;
+        if (pending) {
+            const state = layout.states[pending], repeated = action?.state === pending;
+            pending = null;
+            if (repeated) return {text: state.terminator, stop: true};
+            if (plain && ev.key === ' ') return {text: state.terminator, stop: true};
+            if (ev.key === 'Backspace' || ev.key === 'Escape') return {text: '', stop: true};
+            if (plain && key in state.keys) return {text: act(state.keys[key]), stop: true};
+            // Any other key types the terminator, then acts as if nothing were pending.
+            const rest = press(ev, option);
+            return {text: state.terminator + (rest?.text ?? ''), stop: rest?.stop ?? false};
+        }
+        if (action) return {text: act(action), stop: true};
+    }
+    const reset = () => { pending = null; };
+
+    // At each level (exact, prefix, prefixes of hyphen-separated parts) a name outranks a search word, as in `matches` in `symbols.rs`.
+    function matches(query) {
+        query = query.toLowerCase();
+        const letters = word => word.replaceAll('-', '');
+        let best = Infinity, found = [];
+        for (const {glyph, name, monad, dyad, aliases} of symbols) {
+            let rank = Infinity;
+            [name, monad, dyad, ...aliases.split(' ')].filter(Boolean).forEach((word, i) => {
+                const level = letters(word) === query ? 0 : letters(word).startsWith(query) ? 1 : 2;
+                if (level === 2) {
+                    let rest = query;
+                    for (const part of word.split('-')) {
+                        let n = 0;
+                        while (n < part.length && part[n] === rest[n]) n++;
+                        if (!n) break;
+                        rest = rest.slice(n);
+                        if (!rest) break;
+                    }
+                    if (rest) return;
+                }
+                rank = Math.min(rank, 2 * level + (i > 0));
+            });
+            if (rank < best) { best = rank; found = []; }
+            if (rank < Infinity && rank === best) found.push([glyph, name]);
+        }
+        // A name that is a prefix of every other match wins: `om gives omega, `omu gives omega-underbar.
+        const shortest = found.find(([, a]) => found.every(([, b]) => letters(b).startsWith(letters(a))));
+        return shortest && found.length > 1 ? [shortest] : found;
+    }
+
+    function inCode(text, python = false) {
+        let quote = '', comment = false;
+        for (let i = 0; i < text.length; i++) {
+            const c = text[i];
+            if (comment) { if (c === '\n') comment = false; }
+            else if (quote) {
+                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;
+            } else if (c === "'" || c === '"') {
+                quote = python && text.startsWith(c.repeat(3), i) ? c.repeat(3) : c;
+                i += quote.length - 1;
+            } else if (c === (python ? '#' : '⍝')) comment = true;
+        }
+        return !quote && !comment;
+    }
+
+    function bplStart(e) {
+        if (e.bpl) return 0;
+        const header = /^%%(?:bpl|apl)[^\S\n]*(?:\r?\n|$)/.exec(e.text);
+        if (header) return e.pos >= header[0].length ? header[0].length : -1;
+        const start = e.text.lastIndexOf('\n', e.pos - 1) + 1;
+        const line = /^[ \t]*(?:[\p{ID_Start}_][\p{ID_Continue}]*[ \t]*=[ \t]*)?%bpl[ \t]+/u.exec(e.text.slice(start, e.pos));
+        return line && inCode(e.text.slice(0, start), true) ? start + line[0].length : -1;
+    }
+
+    function entry(e) {
+        const body = bplStart(e), start = e.text.lastIndexOf('`', e.pos - 1);
+        if (body < 0 || start < body || !e.empty || !inCode(e.text.slice(body, start))) return;
+        const query = e.text.slice(start + 1, e.pos);
+        if (/^[a-z]*$/i.test(query)) return {start, query, found: matches(query)};
+    }
+
+    return {matches, inCode, bplStart, entry, press, reset};
+})

package/layout.json

@@ -0,0 +1,80 @@
+{
+ "alt_aliases": {"£": "#"},
+ "option": {
+  "`": {"state": "diamond"},
+  "1": {"state": "diaeresis"},
+  "3": "√",
+  "4": "⇄",
+  "5": {"state": "subscript"},
+  "6": {"state": "superscript"},
+  "7": {"state": "delta"},
+  "8": "∞",
+  "9": {"state": "or"},
+  "0": {"state": "and"},
+  ")": "⍬",
+  "-": {"state": "bar"},
+  "=": {"state": "match"},
+  "q": {"state": "quad"},
+  "w": {"state": "omega"},
+  "e": {"state": "epsilon"},
+  "r": "⍴",
+  "t": "∘",
+  "y": "•",
+  "u": "÷",
+  "i": {"state": "iota"},
+  "o": {"state": "circle"},
+  "p": "π",
+  "+": "≠",
+  "\\": {"state": "stile"},
+  "a": {"state": "alpha"},
+  "s": "⌈",
+  "d": "⌊",
+  "f": "∂",
+  "g": {"state": "del"},
+  "h": "←",
+  "j": "↓",
+  "k": {"state": "take"},
+  "l": "→",
+  ";": "⊣",
+  "'": "⊢",
+  "z": {"state": "enclose"},
+  "x": "⊃",
+  "c": {"state": "cap"},
+  "v": "∪",
+  "b": {"state": "decode"},
+  "n": {"state": "encode"},
+  "m": "×",
+  ",": "↢",
+  ".": "↣",
+  "<": "≤",
+  ">": "≥",
+  "|": "⌽",
+  "/": "¿"
+ },
+ "states": {
+  "diaeresis": {"terminator": "¨", "keys": {"t": "⍤", "o": "⍥", "*": "⍣", "~": "⍨", "g": "⍢", "8": "⍣", "`": "⍨"}},
+  "superscript": {"terminator": "^", "keys": {"0": "⁰", "1": "¹", "2": "²", "3": "³", "4": "⁴", "5": "⁵", "6": "⁶", "7": "⁷", "8": "⁸", "9": "⁹", "-": {"state": "superscript-minus"}, "t": "ᵀ", "u": "ᵘ"}},
+  "superscript-minus": {"terminator": "⁻", "keys": {"0": "⁻⁰", "1": "⁻¹", "2": "⁻²", "3": "⁻³", "4": "⁻⁴", "5": "⁻⁵", "6": "⁻⁶", "7": "⁻⁷", "8": "⁻⁸", "9": "⁻⁹"}},
+  "subscript": {"terminator": "_", "keys": {"0": "₀", "1": "₁", "2": "₂", "3": "₃", "4": "₄", "5": "₅", "6": "₆", "7": "₇", "8": "₈", "9": "₉", "x": "ₓ", "j": "ⱼ", "e": "ₑ", "r": "ᵣ", "-": {"state": "subscript-minus"}}},
+  "subscript-minus": {"terminator": "₋", "keys": {"0": "₋₀", "1": "₋₁", "2": "₋₂", "3": "₋₃", "4": "₋₄", "5": "₋₅", "6": "₋₆", "7": "₋₇", "8": "₋₈", "9": "₋₉"}},
+  "diamond": {"terminator": "⋄", "keys": {"_": "⍚", "-": "⍚"}},
+  "delta": {"terminator": "∆", "keys": {"|": "⍋", "_": "⍙", "\\": "⍋", "-": "⍙"}},
+  "or": {"terminator": "∨", "keys": {"~": "⍱", "`": "⍱"}},
+  "and": {"terminator": "∧", "keys": {"~": "⍲", "`": "⍲"}},
+  "bar": {"terminator": "¯", "keys": {",": "⍪", "\\": "⍀", "/": "⌿"}},
+  "match": {"terminator": "≡", "keys": {"/": "≢"}},
+  "quad": {"terminator": "⎕", "keys": {"t": "⌻", ":": "⍠", "=": "⌸", "u": "⌹", "|": "⌷", "`": "⌺", ";": "⍠", "\\": "⌷"}},
+  "omega": {"terminator": "⍵", "keys": {"_": "⍹", "-": "⍹"}},
+  "epsilon": {"terminator": "∊", "keys": {"_": "⍷", "-": "⍷"}},
+  "iota": {"terminator": "⍳", "keys": {"_": "⍸", "-": "⍸"}},
+  "circle": {"terminator": "○", "keys": {"-": "⊖", "\\": "⍉", "/": "⊘", "*": "⍟", "m": "⊗", "u": "⨸", "t": "⌾", "8": "⍟"}},
+  "stile": {"terminator": "|", "keys": {"~": "⍭", "`": "⍭"}},
+  "alpha": {"terminator": "⍺", "keys": {"_": "⍶", "-": "⍶"}},
+  "del": {"terminator": "∇", "keys": {"|": "⍒", "\\": "⍒"}},
+  "take": {"terminator": "↑", "keys": {"j": "↕"}},
+  "enclose": {"terminator": "⊂", "keys": {"_": "⊆", "-": "⊆"}},
+  "cap": {"terminator": "∩", "keys": {"t": "⍝"}},
+  "decode": {"terminator": "⊥", "keys": {"t": "⍎"}},
+  "encode": {"terminator": "⊤", "keys": {"t": "⍕"}}
+ }
+}

package/lb.js

@@ -0,0 +1,196 @@
+// Based on Adám Brudzewsky's APL language bar: https://abrudz.github.io/lb
+// MIT License, Copyright (c) 2011-2020 Nikolay G. Nikolov and Adam Brudzevski.
+// BPL name completion, editor adapters, dark mode and overlay layout by Jeremy Howard.
+((symbols, input, layout) => {
+    const d = document;
+    // Docs pages have no bar, except a page with a `data-bpl` editor, such as the playground.
+    if (d.querySelector('.ngn_lb') || d.querySelector('meta[name=generator][content^=quarto]') && !d.querySelector('[data-bpl]')) return;
+
+    const {inCode, bplStart, entry, press, reset} = input(symbols, layout);
+    const shortcuts = new Map(symbols.map(({glyph, shortcut}) => [glyph, shortcut]));
+    let leftAlt = false, rightAlt = false;
+
+    function textareaRect(t) {
+        const mirror = d.createElement('div'), caret = d.createElement('span'), css = getComputedStyle(t), rect = t.getBoundingClientRect();
+        for (const p of ['font', 'lineHeight', 'letterSpacing', 'padding', 'border', 'boxSizing', 'width', 'tabSize']) mirror.style[p] = css[p];
+        Object.assign(mirror.style, {position: 'fixed', visibility: 'hidden', whiteSpace: 'pre-wrap', overflowWrap: 'break-word',
+            left: `${rect.left - t.scrollLeft}px`, top: `${rect.top - t.scrollTop}px`});
+        mirror.textContent = t.value.slice(0, t.selectionStart);
+        caret.textContent = '\u200b';
+        mirror.append(caret);
+        d.body.append(mirror);
+        const result = caret.getBoundingClientRect();
+        mirror.remove();
+        return result;
+    }
+
+    function editor(target) {
+        if (target.closest?.('.text_cell, .jp-MarkdownCell')) return;
+        const m = window.monaco?.editor?.getEditors?.().find(e => e.hasTextFocus());
+        if (m) {
+            const model = m.getModel(), p = m.getPosition(), selection = m.getSelection();
+            if (model.getLanguageId() === 'markdown' || m.getOption(window.monaco.editor.EditorOption.readOnly)) return;
+            return {id: m, text: model.getValue(), pos: model.getOffsetAt(p), empty: selection.isEmpty(), bpl: model.getLanguageId() === 'bpl',
+                rect: () => {
+                    const r = m.getDomNode().getBoundingClientRect(), c = m.getScrolledVisiblePosition(p);
+                    return {left: r.left + c.left, bottom: r.top + c.top + c.height};
+                },
+                insert: (text, from = model.getOffsetAt(selection.getStartPosition())) => {
+                    const a = model.getPositionAt(from), b = selection.getEndPosition();
+                    m.pushUndoStop();
+                    m.executeEdits('aplnb', [{range: {startLineNumber: a.lineNumber, startColumn: a.column,
+                        endLineNumber: b.lineNumber, endColumn: b.column}, text}], () => {
+                        const end = model.getPositionAt(from + text.length);
+                        return [new window.monaco.Selection(end.lineNumber, end.column, end.lineNumber, end.column)];
+                    });
+                    m.pushUndoStop();
+                    m.focus();
+                }};
+        }
+        const view = target.closest?.('.cm-editor')?.querySelector('.cm-content')?.cmTile?.view;
+        if (view) {
+            if (view.state.readOnly) return;
+            const sel = view.state.selection.main;
+            return {id: view, text: view.state.doc.toString(), pos: sel.head, empty: sel.empty,
+                rect: () => view.coordsAtPos(sel.head),
+                insert: (text, from = sel.from) => {
+                    view.dispatch({changes: {from, to: sel.to, insert: text}, selection: {anchor: from + text.length}, userEvent: 'input.complete'});
+                    view.focus();
+                }};
+        }
+        if (target.tagName !== 'TEXTAREA' || target.readOnly || target.disabled) return;
+        return {id: target, text: target.value, pos: target.selectionStart, empty: target.selectionStart === target.selectionEnd, bpl: target.hasAttribute('data-bpl'),
+            rect: () => textareaRect(target),
+            insert: (text, from = target.selectionStart) => {
+                target.focus();
+                target.selectionStart = from;
+                d.execCommand('insertText', false, text);
+            }};
+    }
+
+    const host = d.createElement('div');
+    host.innerHTML = `<div class="ngn_lb" aria-label="BPL symbols"><button class="ngn_x" title="Close symbol bar">×</button><button class="ngn_o" title="Toggle overlay/push-down"></button></div>
+        <div class="bpl_choices" role="group" aria-label="BPL symbol completions" hidden></div>
+        <style>
+        .ngn_lb,.bpl_choices{background:#eee;color:#111;font:15px var(--bpl-font),monospace;z-index:2147483647}
+        .ngn_lb{position:fixed;top:0;left:0;right:0;border-bottom:1px solid #999;padding:2px}
+        .ngn_lb button,.bpl_choices button{font:inherit;color:inherit;background:none;border:0;cursor:pointer;padding:2px 4px}
+        .ngn_lb button:hover,.bpl_choices button:hover{background:#777;color:white}
+        .ngn_x,.ngn_o{float:right}
+        .bpl_choices{position:fixed;max-height:240px;max-width:calc(100vw - 16px);overflow:auto;border:1px solid #888;border-radius:4px;box-shadow:0 3px 12px #0003;padding:4px}
+        .bpl_choices button{display:block;width:100%;text-align:left;white-space:nowrap}
+        .bpl_choices small{display:block;padding:4px}
+        @media(prefers-color-scheme:dark){.ngn_lb,.bpl_choices{background:#222;color:#ddd}.ngn_lb button:hover,.bpl_choices button:hover{background:#bbb;color:#111}}
+        </style>`;
+    d.body.append(host);
+    const bar = host.querySelector('.ngn_lb'), tip = host.querySelector('.bpl_choices'), toggle = bar.querySelector('.ngn_o');
+    let overlay = false, active, lastEditor, choice, keyInput = false;
+    const originalPadding = d.body.style.paddingTop;
+    try { overlay = localStorage.getItem('ngn_lb_overlay') === '1'; } catch {}
+    function reflow() {
+        toggle.textContent = overlay ? '▼' : '▲';
+        d.body.style.paddingTop = overlay || bar.hidden ? originalPadding : `${bar.offsetHeight}px`;
+    }
+    function button(glyph, name) {
+        const b = d.createElement('button');
+        b.type = 'button'; b.textContent = glyph; b.title = name + shortcuts.get(glyph); b.dataset.glyph = glyph;
+        return b;
+    }
+    for (const {glyph, name, monad, dyad, aliases} of symbols)
+        bar.append(button(glyph, [...new Set([name, monad, dyad, aliases].join(' ').split(' ').filter(Boolean))].join(' ')));
+    new ResizeObserver(reflow).observe(bar);
+    reflow();
+
+    function cancel() { active = undefined; choice = undefined; tip.hidden = true; }
+    function show(e, item) {
+        if (choice?.item.query !== item.query) {
+            tip.replaceChildren();
+            for (const [glyph, name] of item.found) {
+                const b = button(glyph, name);
+                b.textContent = `${glyph} ${b.title}`;
+                tip.append(b);
+            }
+            if (!item.found.length) {
+                const note = d.createElement('small'); note.textContent = 'Unknown symbol'; tip.append(note);
+            }
+        }
+        choice = {e, item};
+        tip.hidden = false;
+        const r = e.rect();
+        tip.style.left = `${Math.max(4, Math.min(r.left, innerWidth - tip.offsetWidth - 8))}px`;
+        tip.style.top = `${Math.max(bar.hidden || overlay ? 4 : bar.offsetHeight, Math.min(r.bottom + 4, innerHeight - tip.offsetHeight - 8))}px`;
+    }
+    function refresh(target) {
+        const e = editor(target), item = e && entry(e);
+        if (item && active?.id === e.id && active.start === item.start) show(e, item);
+        else cancel();
+    }
+    bar.addEventListener('mousedown', ev => {
+        ev.preventDefault();
+        const b = ev.target.closest('button');
+        if (b?.classList.contains('ngn_x')) { bar.hidden = true; reflow(); }
+        else if (b === toggle) {
+            overlay = !overlay;
+            try { localStorage.setItem('ngn_lb_overlay', overlay ? '1' : '0'); } catch {}
+            reflow();
+        } else if (b?.dataset.glyph && lastEditor) lastEditor.insert(b.dataset.glyph);
+        cancel();
+    });
+    tip.addEventListener('mousedown', ev => {
+        ev.preventDefault();
+        const b = ev.target.closest('button');
+        if (b && choice) choice.e.insert(b.dataset.glyph, choice.item.start);
+        cancel();
+    });
+    d.addEventListener('focusin', ev => { lastEditor = editor(ev.target); cancel(); });
+    d.addEventListener('pointerdown', ev => { if (!host.contains(ev.target)) cancel(); }, true);
+    d.addEventListener('pointerup', ev => { if (!host.contains(ev.target)) lastEditor = editor(ev.target); });
+    for (const event of ['paste', 'cut', 'compositionstart', 'focusout']) d.addEventListener(event, cancel, true);
+    d.addEventListener('input', ev => {
+        if (!keyInput || ev.inputType !== 'insertText' && ev.inputType !== 'deleteContentBackward') cancel();
+        keyInput = false;
+        requestAnimationFrame(() => { lastEditor = editor(ev.target); refresh(ev.target); });
+    });
+    window.addEventListener('blur', () => { leftAlt = rightAlt = false; cancel(); reset(); });
+    window.addEventListener('focusin', reset, true);
+    window.addEventListener('keyup', ev => {
+        if (ev.code === 'AltLeft') leftAlt = false;
+        if (ev.code === 'AltRight') rightAlt = false;
+        keyInput = false; lastEditor = editor(ev.target); if (active) refresh(ev.target);
+    }, true);
+    window.addEventListener('keydown', ev => {
+        keyInput = false;
+        if (ev.code === 'AltLeft') leftAlt = true;
+        if (ev.code === 'AltRight') rightAlt = true;
+        if (['Shift', 'Control', 'Alt', 'Meta'].includes(ev.key)) return;
+        const e = editor(ev.target);
+        if (!e || ev.isComposing || ev.defaultPrevented) { cancel(); return; }
+        lastEditor = e;
+        const body = bplStart(e);
+        const pressed = press(ev, leftAlt && !rightAlt && !ev.getModifierState('AltGraph') && body >= 0);
+        if (pressed) {
+            if (pressed.text) e.insert(pressed.text);
+            if (pressed.stop) { cancel(); ev.preventDefault(); ev.stopImmediatePropagation(); return; }
+        }
+        const item = entry(e), plain = !ev.ctrlKey && !ev.altKey && !ev.metaKey;
+        const tab = ev.key === 'Tab' && plain && !ev.shiftKey, enter = ev.key === 'Enter';
+        const typed = active?.id === e.id && active.start === item?.start;
+        const delimiter = plain && ev.key.length === 1 && !/[a-z]/i.test(ev.key);
+        if (item && (tab || typed && (enter || delimiter))) {
+            if (item.found.length === 1) {
+                e.insert(item.found[0][0], item.start);
+                cancel();
+            } else if (tab) {
+                active = {id: e.id, start: item.start};
+                show(e, item);
+            }
+            if (tab) { ev.preventDefault(); ev.stopImmediatePropagation(); return; }
+        }
+        if (ev.key === '`' && plain) {
+            const updated = editor(ev.target), body = bplStart(updated);
+            if (body >= 0 && updated.empty && inCode(updated.text.slice(body, updated.pos))) active = {id: updated.id, start: updated.pos};
+            else cancel();
+        } else if (!(typed && plain && (/^[a-z]$/i.test(ev.key) || ev.key === 'Backspace'))) cancel();
+        keyInput = plain && (ev.key.length === 1 || ev.key === 'Backspace');
+    }, true);
+})

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "basedpl",
+  "version": "0.1.24",
+  "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": "https://github.com/AnswerDotAI/basedpl",
+  "type": "module",
+  "main": "basedpl_wasm.js"
+}