@thi.ng/pointfree 2.0.36 → 3.0.3

package/lib/index.js

@@ -1,785 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var checks = require('@thi.ng/checks');
-var errors = require('@thi.ng/errors');
-var api = require('@thi.ng/api');
-var compose = require('@thi.ng/compose');
-var equiv$1 = require('@thi.ng/equiv');
-
-exports.ensureStack = void 0;
-exports.ensureStackN = void 0;
-const safeMode = (state) => {
-    if (state) {
-        exports.ensureStackN = (m, n) => m < n && errors.illegalState(`stack underflow`);
-        exports.ensureStack = (stack, n) => exports.ensureStackN(stack.length, n);
-    }
-    else {
-        exports.ensureStack = exports.ensureStackN = api.NO_OP;
-    }
-};
-safeMode(true);
-
-const defOp1 = (op) => {
-    return (ctx) => {
-        const stack = ctx[0];
-        const n = stack.length - 1;
-        exports.ensureStackN(n, 0);
-        stack[n] = op(stack[n]);
-        return ctx;
-    };
-};
-const defOp2 = (op) => (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n] = op(stack.pop(), stack[n]);
-    return ctx;
-};
-const defOp2v = (f) => (ctx) => {
-    exports.ensureStack(ctx[0], 2);
-    const stack = ctx[0];
-    const b = stack.pop();
-    const n = stack.length - 1;
-    const a = stack[n];
-    const isa = checks.isArray(a);
-    const isb = checks.isArray(b);
-    stack[n] =
-        isa && isb
-            ? op2vAB(f, a, b)
-            : isb && !isa
-                ? op2vB(f, a, b)
-                : isa && !isb
-                    ? op2vA(f, a, b)
-                    : errors.illegalArgs("at least one arg must be an array");
-    return ctx;
-};
-const op2vAB = (f, a, b) => {
-    const res = new Array(Math.min(a.length, b.length));
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b[i], a[i]);
-    }
-    return res;
-};
-const op2vA = (f, a, b) => {
-    const res = new Array(a.length);
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b, a[i]);
-    }
-    return res;
-};
-const op2vB = (f, a, b) => {
-    const res = new Array(b.length);
-    for (let i = res.length - 1; i >= 0; i--) {
-        res[i] = f(b[i], a);
-    }
-    return res;
-};
-
-const __xsp = (id) => (ctx) => (ctx[0].push(ctx[id].length), ctx);
-const __dup = (id) => __copy(id, id);
-const __dup2 = (id) => (ctx) => {
-    const stack = ctx[id];
-    let n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack.push(stack[n], stack[n + 1]);
-    return ctx;
-};
-const __dup3 = (id) => (ctx) => {
-    const stack = ctx[id];
-    let n = stack.length - 3;
-    exports.ensureStackN(n, 0);
-    stack.push(stack[n], stack[n + 1], stack[n + 2]);
-    return ctx;
-};
-const __drop = (id, n = 1) => (ctx) => (exports.ensureStack(ctx[id], 1), (ctx[id].length -= n), ctx);
-const __swap = (i) => (ctx) => {
-    const stack = ctx[i];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    const a = stack[n];
-    stack[n] = stack[n + 1];
-    stack[n + 1] = a;
-    return ctx;
-};
-const __swap2 = (i) => (ctx) => {
-    const stack = ctx[i];
-    let n = stack.length - 1;
-    exports.ensureStackN(n, 3);
-    let a = stack[n];
-    stack[n] = stack[n - 2];
-    stack[n - 2] = a;
-    n--;
-    a = stack[n];
-    stack[n] = stack[n - 2];
-    stack[n - 2] = a;
-    return ctx;
-};
-const __over = (id) => (ctx) => {
-    const stack = ctx[id];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack.push(stack[n]);
-    return ctx;
-};
-const __move = (src, dest) => (ctx) => (exports.ensureStack(ctx[src], 1), ctx[dest].push(ctx[src].pop()), ctx);
-const __move2 = (a, b) => (ctx) => {
-    const src = ctx[a];
-    exports.ensureStack(src, 2);
-    const v = src.pop();
-    ctx[b].push(src.pop(), v);
-    return ctx;
-};
-const __copy = (src, dest) => (ctx) => (exports.ensureStack(ctx[src], 1), ctx[dest].push(tos(ctx[src])), ctx);
-const __copy2 = (a, b) => (ctx) => {
-    const src = ctx[a];
-    const n = src.length - 2;
-    exports.ensureStackN(n, 0);
-    ctx[b].push(src[n], src[n + 1]);
-    return ctx;
-};
-const __incdec = (id, n) => (ctx) => (exports.ensureStack(ctx[id], 1), (ctx[id][ctx[id].length - 1] += n), ctx);
-const tos = (stack) => stack[stack.length - 1];
-const nop = (ctx) => ctx;
-const dsp = __xsp(0);
-const pick = (ctx) => {
-    const stack = ctx[0];
-    let n = stack.length - 1;
-    exports.ensureStackN(n, 0);
-    exports.ensureStackN((n -= stack.pop() + 1), 0);
-    stack.push(stack[n]);
-    return ctx;
-};
-const drop = __drop(0);
-const drop2 = __drop(0, 2);
-const dropif = (ctx) => (exports.ensureStack(ctx[0], 1), tos(ctx[0]) && ctx[0].length--, ctx);
-const defPush = (...args) => (ctx) => (ctx[0].push(...args), ctx);
-const dup = __dup(0);
-const dup2 = __dup2(0);
-const dup3 = __dup3(0);
-const dupif = (ctx) => {
-    exports.ensureStack(ctx[0], 1);
-    const x = tos(ctx[0]);
-    x && ctx[0].push(x);
-    return ctx;
-};
-const swap = __swap(0);
-const swap2 = __swap2(0);
-const nip = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n] = stack.pop();
-    return ctx;
-};
-const tuck = (ctx) => {
-    exports.ensureStack(ctx[0], 2);
-    const stack = ctx[0];
-    const a = stack.pop();
-    stack.push(a, stack.pop(), a);
-    return ctx;
-};
-const rot = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 1;
-    exports.ensureStackN(n, 2);
-    const c = stack[n - 2];
-    stack[n - 2] = stack[n - 1];
-    stack[n - 1] = stack[n];
-    stack[n] = c;
-    return ctx;
-};
-const invrot = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 1;
-    exports.ensureStackN(n, 2);
-    const c = stack[n];
-    stack[n] = stack[n - 1];
-    stack[n - 1] = stack[n - 2];
-    stack[n - 2] = c;
-    return ctx;
-};
-const over = __over(0);
-const inc = __incdec(0, 1);
-const dec = __incdec(0, -1);
-const rsp = __xsp(1);
-const rdup = __dup(1);
-const rdup2 = __dup2(1);
-const rdup3 = __dup3(1);
-const rdrop = __drop(1);
-const rdrop2 = __drop(1, 2);
-const movdr = __move(0, 1);
-const movrd = __move(1, 0);
-const cpdr = __copy(0, 1);
-const cprd = __copy(1, 0);
-const movdr2 = __move2(0, 1);
-const movrd2 = __move2(1, 0);
-const cpdr2 = __copy2(0, 1);
-const cprd2 = __copy2(1, 0);
-const rswap = __swap(1);
-const rswap2 = __swap2(1);
-const rover = __over(1);
-const rinc = __incdec(1, 1);
-const rdec = __incdec(1, -1);
-
-const $stackFn = (f) => (checks.isArray(f) ? defWord(f) : f);
-const compile = (prog) => prog.length > 0
-    ? compose.compL.apply(null, (prog.map((w) => !checks.isFunction(w)
-        ? (ctx) => (ctx[0].push(w), ctx)
-        : w)))
-    : (ctx) => ctx;
-const unwrap = ([stack], n = 1) => n === 1 ? tos(stack) : stack.slice(Math.max(0, stack.length - n));
-const defWord = (prog, env, mergeEnv = true) => {
-    const w = compile(prog);
-    return env
-        ? mergeEnv
-            ? (ctx) => (w([ctx[0], ctx[1], Object.assign(Object.assign({}, ctx[2]), env)]), ctx)
-            : (ctx) => (w([ctx[0], ctx[1], Object.assign({}, env)]), ctx)
-        : w;
-};
-const defWordU = (prog, n = 1, env, mergeEnv = true) => {
-    const w = compile(prog);
-    return env
-        ? mergeEnv
-            ? (ctx) => unwrap(w([ctx[0], ctx[1], Object.assign(Object.assign({}, ctx[2]), env)]), n)
-            : (ctx) => unwrap(w([ctx[0], ctx[1], Object.assign({}, env)]), n)
-        : (ctx) => unwrap(w(ctx), n);
-};
-const exec = (ctx) => (exports.ensureStack(ctx[0], 1), $stackFn(ctx[0].pop())(ctx));
-const $try = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const err = stack.pop();
-    try {
-        return exec(ctx);
-    }
-    catch (e) {
-        stack.push(e, err);
-        return exec(ctx);
-    }
-};
-const execjs = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 1);
-    const [fn, ...args] = stack.pop();
-    stack.push(fn(...args));
-    return ctx;
-};
-
-const list = (ctx) => (ctx[0].push([]), ctx);
-const obj = (ctx) => (ctx[0].push({}), ctx);
-const pushl = (ctx) => {
-    exports.ensureStack(ctx[0], 2);
-    const stack = ctx[0];
-    const a = stack.pop();
-    a.unshift(stack.pop());
-    stack.push(a);
-    return ctx;
-};
-const pushr = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n].push(stack[n + 1]);
-    stack.length--;
-    return ctx;
-};
-const popr = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 1;
-    exports.ensureStackN(n, 0);
-    const a = stack[n];
-    !a.length && errors.illegalState("can't pop empty array");
-    stack.push(a.pop());
-    return ctx;
-};
-const pull = defWord([popr, swap]);
-const pull2 = defWord([pull, pull]);
-const pull3 = defWord([pull2, pull]);
-const pull4 = defWord([pull2, pull2]);
-const vadd = defOp2v((b, a) => a + b);
-const vsub = defOp2v((b, a) => a - b);
-const vmul = defOp2v((b, a) => a * b);
-const vdiv = defOp2v((b, a) => a / b);
-const split = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    const a = stack[n];
-    const b = stack[n + 1];
-    stack[n + 1] = a.splice(b, a.length - b);
-    return ctx;
-};
-const cat = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n] = stack[n].concat(stack.pop());
-    return ctx;
-};
-const catr = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n] = stack.pop().concat(stack[n]);
-    return ctx;
-};
-const mapl = (ctx) => {
-    exports.ensureStack(ctx[0], 2);
-    const stack = ctx[0];
-    const w = $stackFn(stack.pop());
-    const list = stack.pop();
-    const n = list.length;
-    for (let i = 0; i < n; i++) {
-        ctx[0].push(list[i]);
-        ctx = w(ctx);
-    }
-    return ctx;
-};
-const mapll = (ctx) => {
-    exports.ensureStack(ctx[0], 2);
-    let stack = ctx[0];
-    const w = $stackFn(stack.pop());
-    const list = stack.pop();
-    const n = list.length;
-    let r = 0;
-    for (let i = 0; i < n; i++) {
-        let m = stack.length;
-        stack.push(list[i]);
-        ctx = w(ctx);
-        stack = ctx[0];
-        r += stack.length - m;
-    }
-    stack.push(stack.splice(stack.length - r, r));
-    return ctx;
-};
-const foldl = defWord([invrot, mapl]);
-const collect = (ctx) => {
-    const stack = ctx[0];
-    let n = stack.length - 1, m;
-    exports.ensureStackN(n, 0);
-    exports.ensureStackN((n -= m = stack.pop()), 0);
-    stack.push(stack.splice(n, m));
-    return ctx;
-};
-const defTuple = (n) => defWord([n, collect]);
-const vec2 = defTuple(2);
-const vec3 = defTuple(3);
-const vec4 = defTuple(4);
-const defJoin = (sep = "") => defOp1((x) => x.join(sep));
-const join = defOp2((sep, buf) => buf.join(sep));
-const length = defOp1((x) => x.length);
-const copy = defOp1((x) => checks.isArray(x)
-    ? x.slice()
-    : checks.isPlainObject(x)
-        ? Object.assign({}, x) : errors.illegalArgs(`can't copy type ${typeof x}`));
-const at = defOp2((b, a) => a[b]);
-const setat = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 3;
-    exports.ensureStackN(n, 0);
-    stack[n + 1][stack[n + 2]] = stack[n];
-    stack[n] = stack[n + 1];
-    stack.length -= 2;
-    return ctx;
-};
-const bindkeys = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const obj = stack.pop();
-    const keys = stack.pop();
-    exports.ensureStack(stack, keys.length);
-    for (let i = keys.length - 1; i >= 0; i--) {
-        obj[keys[i]] = stack.pop();
-    }
-    stack.push(obj);
-    return ctx;
-};
-
-const bitand = defOp2((b, a) => a & b);
-const bitor = defOp2((b, a) => a | b);
-const bitxor = defOp2((b, a) => a ^ b);
-const bitnot = defOp1((x) => ~x);
-const lsl = defOp2((b, a) => a << b);
-const lsr = defOp2((b, a) => a >> b);
-const lsru = defOp2((b, a) => a >>> b);
-
-const defCond = (_then, _else = nop) => (ctx) => (exports.ensureStack(ctx[0], 1), $stackFn(ctx[0].pop() ? _then : _else)(ctx));
-const condq = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 3);
-    const _else = stack.pop();
-    const _then = stack.pop();
-    return $stackFn(stack.pop() ? _then : _else)(ctx);
-};
-const whenq = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const _then = stack.pop();
-    return stack.pop() ? $stackFn(_then)(ctx) : ctx;
-};
-const defCases = (cases) => (ctx) => {
-    exports.ensureStack(ctx[0], 1);
-    const stack = ctx[0];
-    const tos = stack.pop();
-    const cas = cases[tos];
-    if (cas !== undefined) {
-        return $stackFn(cas)(ctx);
-    }
-    if (cases.default) {
-        stack.push(tos);
-        return $stackFn(cases.default)(ctx);
-    }
-    return errors.illegalState(`no matching case for: ${tos}`);
-};
-const casesq = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    return defCases(stack.pop())(ctx);
-};
-
-const ctx = (stack = [], env = {}) => [
-    stack,
-    [],
-    env,
-];
-
-const eq = defOp2((b, a) => a === b);
-const equiv = defOp2(equiv$1.equiv);
-const neq = defOp2((b, a) => a !== b);
-const and = defOp2((b, a) => !!a && !!b);
-const or = defOp2((b, a) => !!a || !!b);
-const not = defOp1((x) => !x);
-const lt = defOp2((b, a) => a < b);
-const gt = defOp2((b, a) => a > b);
-const lteq = defOp2((b, a) => a <= b);
-const gteq = defOp2((b, a) => a >= b);
-const iszero = defOp1((x) => x === 0);
-const ispos = defOp1((x) => x > 0);
-const isneg = defOp1((x) => x < 0);
-const isnull = defOp1((x) => x == null);
-
-const dip = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const q = stack.pop();
-    const x = stack.pop();
-    ctx = $stackFn(q)(ctx);
-    ctx[0].push(x);
-    return ctx;
-};
-const dip2 = defWord([swap, [dip], dip]);
-const dip3 = defWord([swap, [dip2], dip]);
-const dip4 = defWord([swap, [dip3], dip]);
-const keep = defWord([over, [exec], dip]);
-const keep2 = defWord([[dup2], dip, dip2]);
-const keep3 = defWord([[dup3], dip, dip3]);
-const bi = defWord([[keep], dip, exec]);
-const bi2 = defWord([[keep2], dip, exec]);
-const bi3 = defWord([[keep3], dip, exec]);
-const tri = defWord([[[keep], dip, keep], dip, exec]);
-const tri2 = defWord([[[keep2], dip, keep2], dip, exec]);
-const tri3 = defWord([[[keep3], dip, keep3], dip, exec]);
-const bis = defWord([[dip], dip, exec]);
-const bis2 = defWord([[dip2], dip, exec]);
-const tris = defWord([[[dip2], dip, dip], dip, exec]);
-const tris2 = defWord([[dip4], dip2, bis2]);
-const bia = defWord([dup, bis]);
-const bia2 = defWord([dup, bis2]);
-const tria = defWord([dup, dup, tris]);
-const tria2 = defWord([dup, dup, tris2]);
-const both = defWord([bia, and]);
-const either = defWord([bia, or]);
-
-const pushenv = (ctx) => (ctx[0].push(ctx[2]), ctx);
-const load = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 1);
-    const id = stack.pop();
-    !ctx[2].hasOwnProperty(id) && errors.illegalArgs(`unknown var: ${id}`);
-    stack.push(ctx[2][id]);
-    return ctx;
-};
-const store = (ctx) => (exports.ensureStack(ctx[0], 2), (ctx[2][ctx[0].pop()] = ctx[0].pop()), ctx);
-const defLoadKey = (key) => (ctx) => {
-    !ctx[2].hasOwnProperty(key) &&
-        errors.illegalArgs(`unknown var: ${key.toString()}`);
-    ctx[0].push(ctx[2][key]);
-    return ctx;
-};
-const defStoreKey = (key) => (ctx) => (exports.ensureStack(ctx[0], 1), (ctx[2][key] = ctx[0].pop()), ctx);
-
-const print = (ctx) => (exports.ensureStack(ctx[0], 1), console.log(ctx[0].pop()), ctx);
-const printds = (ctx) => (console.log(ctx[0]), ctx);
-const printrs = (ctx) => (console.log(ctx[1]), ctx);
-
-const defLoop = (test, body) => {
-    const _test = $stackFn(test);
-    const _body = $stackFn(body);
-    return (ctx) => {
-        while (true) {
-            ctx = _test(ctx);
-            exports.ensureStack(ctx[0], 1);
-            if (!ctx[0].pop()) {
-                return ctx;
-            }
-            ctx = _body(ctx);
-        }
-    };
-};
-const loopq = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const body = stack.pop();
-    return defLoop(stack.pop(), body)(ctx);
-};
-const dotimes = (ctx) => {
-    let stack = ctx[0];
-    exports.ensureStack(stack, 2);
-    const w = $stackFn(stack.pop());
-    for (let i = 0, n = stack.pop(); i < n; i++) {
-        ctx[0].push(i);
-        ctx = w(ctx);
-    }
-    return ctx;
-};
-
-const add = defOp2((b, a) => a + b);
-const mul = defOp2((b, a) => a * b);
-const sub = defOp2((b, a) => a - b);
-const div = defOp2((b, a) => a / b);
-const oneover = defWord([1, swap, div]);
-const mod = defOp2((b, a) => a % b);
-const min = defOp2(Math.min);
-const max = defOp2(Math.max);
-const neg = defOp1((x) => -x);
-const pow = defOp2((b, a) => Math.pow(a, b));
-const sqrt = defOp1(Math.sqrt);
-const exp = defOp1(Math.exp);
-const log = defOp1(Math.log);
-const sin = defOp1(Math.sin);
-const cos = defOp1(Math.cos);
-const tan = defOp1(Math.tan);
-const tanh = defOp1(Math.tanh);
-const floor = defOp1(Math.floor);
-const ceil = defOp1(Math.ceil);
-const hypot = defOp2(Math.hypot);
-const atan2 = defOp2(Math.atan2);
-const rand = (ctx) => (ctx[0].push(Math.random()), ctx);
-const even = defOp1((x) => !(x & 1));
-const odd = defOp1((x) => !!(x & 1));
-
-const run = (prog, ctx = [[], [], {}]) => {
-    if (checks.isFunction(prog)) {
-        return prog(ctx);
-    }
-    for (let p = checks.isArray(prog) ? prog : [prog], n = p.length, i = 0, w; i < n; i++) {
-        if (checks.isFunction((w = p[i]))) {
-            ctx = w(ctx);
-        }
-        else {
-            ctx[0].push(w);
-        }
-    }
-    return ctx;
-};
-const runU = (prog, ctx, n = 1) => unwrap(run(prog, ctx), n);
-const runE = (prog, ctx) => run(prog, ctx)[2];
-
-const ismatch = (ctx) => {
-    const stack = ctx[0];
-    const n = stack.length - 2;
-    exports.ensureStackN(n, 0);
-    stack[n] = new RegExp(stack[n + 1]).test(stack[n]);
-    stack.length--;
-    return ctx;
-};
-const fromjson = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 1);
-    stack.push(JSON.parse(stack.pop()));
-    return ctx;
-};
-const tojson = (ctx) => {
-    const stack = ctx[0];
-    exports.ensureStack(stack, 1);
-    stack.push(JSON.stringify(stack.pop(), null, 4));
-    return ctx;
-};
-
-exports.$ = exports.ensureStack;
-exports.$n = exports.ensureStackN;
-exports.$stackFn = $stackFn;
-exports.$try = $try;
-exports.add = add;
-exports.and = and;
-exports.at = at;
-exports.atan2 = atan2;
-exports.bi = bi;
-exports.bi2 = bi2;
-exports.bi3 = bi3;
-exports.bia = bia;
-exports.bia2 = bia2;
-exports.bindkeys = bindkeys;
-exports.bis = bis;
-exports.bis2 = bis2;
-exports.bitand = bitand;
-exports.bitnot = bitnot;
-exports.bitor = bitor;
-exports.bitxor = bitxor;
-exports.both = both;
-exports.casesq = casesq;
-exports.cat = cat;
-exports.catr = catr;
-exports.ceil = ceil;
-exports.collect = collect;
-exports.condq = condq;
-exports.copy = copy;
-exports.cos = cos;
-exports.cpdr = cpdr;
-exports.cpdr2 = cpdr2;
-exports.cprd = cprd;
-exports.cprd2 = cprd2;
-exports.ctx = ctx;
-exports.dec = dec;
-exports.defCases = defCases;
-exports.defCond = defCond;
-exports.defJoin = defJoin;
-exports.defLoadKey = defLoadKey;
-exports.defLoop = defLoop;
-exports.defPush = defPush;
-exports.defStoreKey = defStoreKey;
-exports.defTuple = defTuple;
-exports.defWord = defWord;
-exports.defWordU = defWordU;
-exports.dip = dip;
-exports.dip2 = dip2;
-exports.dip3 = dip3;
-exports.dip4 = dip4;
-exports.div = div;
-exports.dotimes = dotimes;
-exports.drop = drop;
-exports.drop2 = drop2;
-exports.dropif = dropif;
-exports.dsp = dsp;
-exports.dup = dup;
-exports.dup2 = dup2;
-exports.dup3 = dup3;
-exports.dupif = dupif;
-exports.either = either;
-exports.eq = eq;
-exports.equiv = equiv;
-exports.even = even;
-exports.exec = exec;
-exports.execjs = execjs;
-exports.exp = exp;
-exports.floor = floor;
-exports.foldl = foldl;
-exports.fromjson = fromjson;
-exports.gt = gt;
-exports.gteq = gteq;
-exports.hypot = hypot;
-exports.inc = inc;
-exports.invrot = invrot;
-exports.ismatch = ismatch;
-exports.isneg = isneg;
-exports.isnull = isnull;
-exports.ispos = ispos;
-exports.iszero = iszero;
-exports.join = join;
-exports.keep = keep;
-exports.keep2 = keep2;
-exports.keep3 = keep3;
-exports.length = length;
-exports.list = list;
-exports.load = load;
-exports.log = log;
-exports.loopq = loopq;
-exports.lsl = lsl;
-exports.lsr = lsr;
-exports.lsru = lsru;
-exports.lt = lt;
-exports.lteq = lteq;
-exports.map2 = defOp2;
-exports.mapl = mapl;
-exports.mapll = mapll;
-exports.maptos = defOp1;
-exports.max = max;
-exports.min = min;
-exports.mod = mod;
-exports.movdr = movdr;
-exports.movdr2 = movdr2;
-exports.movrd = movrd;
-exports.movrd2 = movrd2;
-exports.mul = mul;
-exports.neg = neg;
-exports.neq = neq;
-exports.nip = nip;
-exports.nop = nop;
-exports.not = not;
-exports.obj = obj;
-exports.odd = odd;
-exports.oneover = oneover;
-exports.op2v = defOp2v;
-exports.or = or;
-exports.over = over;
-exports.pick = pick;
-exports.popr = popr;
-exports.pow = pow;
-exports.print = print;
-exports.printds = printds;
-exports.printrs = printrs;
-exports.pull = pull;
-exports.pull2 = pull2;
-exports.pull3 = pull3;
-exports.pull4 = pull4;
-exports.pushenv = pushenv;
-exports.pushl = pushl;
-exports.pushr = pushr;
-exports.rand = rand;
-exports.rdec = rdec;
-exports.rdrop = rdrop;
-exports.rdrop2 = rdrop2;
-exports.rdup = rdup;
-exports.rdup2 = rdup2;
-exports.rdup3 = rdup3;
-exports.rinc = rinc;
-exports.rot = rot;
-exports.rover = rover;
-exports.rsp = rsp;
-exports.rswap = rswap;
-exports.rswap2 = rswap2;
-exports.run = run;
-exports.runE = runE;
-exports.runU = runU;
-exports.safeMode = safeMode;
-exports.setat = setat;
-exports.sin = sin;
-exports.split = split;
-exports.sqrt = sqrt;
-exports.store = store;
-exports.sub = sub;
-exports.swap = swap;
-exports.swap2 = swap2;
-exports.tan = tan;
-exports.tanh = tanh;
-exports.tojson = tojson;
-exports.tos = tos;
-exports.tri = tri;
-exports.tri2 = tri2;
-exports.tri3 = tri3;
-exports.tria = tria;
-exports.tria2 = tria2;
-exports.tris = tris;
-exports.tris2 = tris2;
-exports.tuck = tuck;
-exports.unwrap = unwrap;
-exports.vadd = vadd;
-exports.vdiv = vdiv;
-exports.vec2 = vec2;
-exports.vec3 = vec3;
-exports.vec4 = vec4;
-exports.vmul = vmul;
-exports.vsub = vsub;
-exports.whenq = whenq;