Spaces:
Runtime error
Runtime error
| ; | |
| Object.defineProperty(exports, "__esModule", { value: true }); | |
| exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0; | |
| const code_1 = require("./code"); | |
| const scope_1 = require("./scope"); | |
| var code_2 = require("./code"); | |
| Object.defineProperty(exports, "_", { enumerable: true, get: function () { return code_2._; } }); | |
| Object.defineProperty(exports, "str", { enumerable: true, get: function () { return code_2.str; } }); | |
| Object.defineProperty(exports, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } }); | |
| Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return code_2.nil; } }); | |
| Object.defineProperty(exports, "getProperty", { enumerable: true, get: function () { return code_2.getProperty; } }); | |
| Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return code_2.stringify; } }); | |
| Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function () { return code_2.regexpCode; } }); | |
| Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return code_2.Name; } }); | |
| var scope_2 = require("./scope"); | |
| Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return scope_2.Scope; } }); | |
| Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function () { return scope_2.ValueScope; } }); | |
| Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function () { return scope_2.ValueScopeName; } }); | |
| Object.defineProperty(exports, "varKinds", { enumerable: true, get: function () { return scope_2.varKinds; } }); | |
| exports.operators = { | |
| GT: new code_1._Code(">"), | |
| GTE: new code_1._Code(">="), | |
| LT: new code_1._Code("<"), | |
| LTE: new code_1._Code("<="), | |
| EQ: new code_1._Code("==="), | |
| NEQ: new code_1._Code("!=="), | |
| NOT: new code_1._Code("!"), | |
| OR: new code_1._Code("||"), | |
| AND: new code_1._Code("&&"), | |
| ADD: new code_1._Code("+"), | |
| }; | |
| class Node { | |
| optimizeNodes() { | |
| return this; | |
| } | |
| optimizeNames(_names, _constants) { | |
| return this; | |
| } | |
| } | |
| class Def extends Node { | |
| constructor(varKind, name, rhs) { | |
| super(); | |
| this.varKind = varKind; | |
| this.name = name; | |
| this.rhs = rhs; | |
| } | |
| render({ es5, _n }) { | |
| const varKind = es5 ? scope_1.varKinds.var : this.varKind; | |
| const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`; | |
| return `${varKind} ${this.name}${rhs};` + _n; | |
| } | |
| optimizeNames(names, constants) { | |
| if (!names[this.name.str]) | |
| return; | |
| if (this.rhs) | |
| this.rhs = optimizeExpr(this.rhs, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {}; | |
| } | |
| } | |
| class Assign extends Node { | |
| constructor(lhs, rhs, sideEffects) { | |
| super(); | |
| this.lhs = lhs; | |
| this.rhs = rhs; | |
| this.sideEffects = sideEffects; | |
| } | |
| render({ _n }) { | |
| return `${this.lhs} = ${this.rhs};` + _n; | |
| } | |
| optimizeNames(names, constants) { | |
| if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) | |
| return; | |
| this.rhs = optimizeExpr(this.rhs, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }; | |
| return addExprNames(names, this.rhs); | |
| } | |
| } | |
| class AssignOp extends Assign { | |
| constructor(lhs, op, rhs, sideEffects) { | |
| super(lhs, rhs, sideEffects); | |
| this.op = op; | |
| } | |
| render({ _n }) { | |
| return `${this.lhs} ${this.op}= ${this.rhs};` + _n; | |
| } | |
| } | |
| class Label extends Node { | |
| constructor(label) { | |
| super(); | |
| this.label = label; | |
| this.names = {}; | |
| } | |
| render({ _n }) { | |
| return `${this.label}:` + _n; | |
| } | |
| } | |
| class Break extends Node { | |
| constructor(label) { | |
| super(); | |
| this.label = label; | |
| this.names = {}; | |
| } | |
| render({ _n }) { | |
| const label = this.label ? ` ${this.label}` : ""; | |
| return `break${label};` + _n; | |
| } | |
| } | |
| class Throw extends Node { | |
| constructor(error) { | |
| super(); | |
| this.error = error; | |
| } | |
| render({ _n }) { | |
| return `throw ${this.error};` + _n; | |
| } | |
| get names() { | |
| return this.error.names; | |
| } | |
| } | |
| class AnyCode extends Node { | |
| constructor(code) { | |
| super(); | |
| this.code = code; | |
| } | |
| render({ _n }) { | |
| return `${this.code};` + _n; | |
| } | |
| optimizeNodes() { | |
| return `${this.code}` ? this : undefined; | |
| } | |
| optimizeNames(names, constants) { | |
| this.code = optimizeExpr(this.code, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| return this.code instanceof code_1._CodeOrName ? this.code.names : {}; | |
| } | |
| } | |
| class ParentNode extends Node { | |
| constructor(nodes = []) { | |
| super(); | |
| this.nodes = nodes; | |
| } | |
| render(opts) { | |
| return this.nodes.reduce((code, n) => code + n.render(opts), ""); | |
| } | |
| optimizeNodes() { | |
| const { nodes } = this; | |
| let i = nodes.length; | |
| while (i--) { | |
| const n = nodes[i].optimizeNodes(); | |
| if (Array.isArray(n)) | |
| nodes.splice(i, 1, ...n); | |
| else if (n) | |
| nodes[i] = n; | |
| else | |
| nodes.splice(i, 1); | |
| } | |
| return nodes.length > 0 ? this : undefined; | |
| } | |
| optimizeNames(names, constants) { | |
| const { nodes } = this; | |
| let i = nodes.length; | |
| while (i--) { | |
| // iterating backwards improves 1-pass optimization | |
| const n = nodes[i]; | |
| if (n.optimizeNames(names, constants)) | |
| continue; | |
| subtractNames(names, n.names); | |
| nodes.splice(i, 1); | |
| } | |
| return nodes.length > 0 ? this : undefined; | |
| } | |
| get names() { | |
| return this.nodes.reduce((names, n) => addNames(names, n.names), {}); | |
| } | |
| } | |
| class BlockNode extends ParentNode { | |
| render(opts) { | |
| return "{" + opts._n + super.render(opts) + "}" + opts._n; | |
| } | |
| } | |
| class Root extends ParentNode { | |
| } | |
| class Else extends BlockNode { | |
| } | |
| Else.kind = "else"; | |
| class If extends BlockNode { | |
| constructor(condition, nodes) { | |
| super(nodes); | |
| this.condition = condition; | |
| } | |
| render(opts) { | |
| let code = `if(${this.condition})` + super.render(opts); | |
| if (this.else) | |
| code += "else " + this.else.render(opts); | |
| return code; | |
| } | |
| optimizeNodes() { | |
| super.optimizeNodes(); | |
| const cond = this.condition; | |
| if (cond === true) | |
| return this.nodes; // else is ignored here | |
| let e = this.else; | |
| if (e) { | |
| const ns = e.optimizeNodes(); | |
| e = this.else = Array.isArray(ns) ? new Else(ns) : ns; | |
| } | |
| if (e) { | |
| if (cond === false) | |
| return e instanceof If ? e : e.nodes; | |
| if (this.nodes.length) | |
| return this; | |
| return new If(not(cond), e instanceof If ? [e] : e.nodes); | |
| } | |
| if (cond === false || !this.nodes.length) | |
| return undefined; | |
| return this; | |
| } | |
| optimizeNames(names, constants) { | |
| var _a; | |
| this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); | |
| if (!(super.optimizeNames(names, constants) || this.else)) | |
| return; | |
| this.condition = optimizeExpr(this.condition, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| const names = super.names; | |
| addExprNames(names, this.condition); | |
| if (this.else) | |
| addNames(names, this.else.names); | |
| return names; | |
| } | |
| } | |
| If.kind = "if"; | |
| class For extends BlockNode { | |
| } | |
| For.kind = "for"; | |
| class ForLoop extends For { | |
| constructor(iteration) { | |
| super(); | |
| this.iteration = iteration; | |
| } | |
| render(opts) { | |
| return `for(${this.iteration})` + super.render(opts); | |
| } | |
| optimizeNames(names, constants) { | |
| if (!super.optimizeNames(names, constants)) | |
| return; | |
| this.iteration = optimizeExpr(this.iteration, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| return addNames(super.names, this.iteration.names); | |
| } | |
| } | |
| class ForRange extends For { | |
| constructor(varKind, name, from, to) { | |
| super(); | |
| this.varKind = varKind; | |
| this.name = name; | |
| this.from = from; | |
| this.to = to; | |
| } | |
| render(opts) { | |
| const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; | |
| const { name, from, to } = this; | |
| return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); | |
| } | |
| get names() { | |
| const names = addExprNames(super.names, this.from); | |
| return addExprNames(names, this.to); | |
| } | |
| } | |
| class ForIter extends For { | |
| constructor(loop, varKind, name, iterable) { | |
| super(); | |
| this.loop = loop; | |
| this.varKind = varKind; | |
| this.name = name; | |
| this.iterable = iterable; | |
| } | |
| render(opts) { | |
| return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); | |
| } | |
| optimizeNames(names, constants) { | |
| if (!super.optimizeNames(names, constants)) | |
| return; | |
| this.iterable = optimizeExpr(this.iterable, names, constants); | |
| return this; | |
| } | |
| get names() { | |
| return addNames(super.names, this.iterable.names); | |
| } | |
| } | |
| class Func extends BlockNode { | |
| constructor(name, args, async) { | |
| super(); | |
| this.name = name; | |
| this.args = args; | |
| this.async = async; | |
| } | |
| render(opts) { | |
| const _async = this.async ? "async " : ""; | |
| return `${_async}function ${this.name}(${this.args})` + super.render(opts); | |
| } | |
| } | |
| Func.kind = "func"; | |
| class Return extends ParentNode { | |
| render(opts) { | |
| return "return " + super.render(opts); | |
| } | |
| } | |
| Return.kind = "return"; | |
| class Try extends BlockNode { | |
| render(opts) { | |
| let code = "try" + super.render(opts); | |
| if (this.catch) | |
| code += this.catch.render(opts); | |
| if (this.finally) | |
| code += this.finally.render(opts); | |
| return code; | |
| } | |
| optimizeNodes() { | |
| var _a, _b; | |
| super.optimizeNodes(); | |
| (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes(); | |
| (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes(); | |
| return this; | |
| } | |
| optimizeNames(names, constants) { | |
| var _a, _b; | |
| super.optimizeNames(names, constants); | |
| (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants); | |
| (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants); | |
| return this; | |
| } | |
| get names() { | |
| const names = super.names; | |
| if (this.catch) | |
| addNames(names, this.catch.names); | |
| if (this.finally) | |
| addNames(names, this.finally.names); | |
| return names; | |
| } | |
| } | |
| class Catch extends BlockNode { | |
| constructor(error) { | |
| super(); | |
| this.error = error; | |
| } | |
| render(opts) { | |
| return `catch(${this.error})` + super.render(opts); | |
| } | |
| } | |
| Catch.kind = "catch"; | |
| class Finally extends BlockNode { | |
| render(opts) { | |
| return "finally" + super.render(opts); | |
| } | |
| } | |
| Finally.kind = "finally"; | |
| class CodeGen { | |
| constructor(extScope, opts = {}) { | |
| this._values = {}; | |
| this._blockStarts = []; | |
| this._constants = {}; | |
| this.opts = { ...opts, _n: opts.lines ? "\n" : "" }; | |
| this._extScope = extScope; | |
| this._scope = new scope_1.Scope({ parent: extScope }); | |
| this._nodes = [new Root()]; | |
| } | |
| toString() { | |
| return this._root.render(this.opts); | |
| } | |
| // returns unique name in the internal scope | |
| name(prefix) { | |
| return this._scope.name(prefix); | |
| } | |
| // reserves unique name in the external scope | |
| scopeName(prefix) { | |
| return this._extScope.name(prefix); | |
| } | |
| // reserves unique name in the external scope and assigns value to it | |
| scopeValue(prefixOrName, value) { | |
| const name = this._extScope.value(prefixOrName, value); | |
| const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set()); | |
| vs.add(name); | |
| return name; | |
| } | |
| getScopeValue(prefix, keyOrRef) { | |
| return this._extScope.getValue(prefix, keyOrRef); | |
| } | |
| // return code that assigns values in the external scope to the names that are used internally | |
| // (same names that were returned by gen.scopeName or gen.scopeValue) | |
| scopeRefs(scopeName) { | |
| return this._extScope.scopeRefs(scopeName, this._values); | |
| } | |
| scopeCode() { | |
| return this._extScope.scopeCode(this._values); | |
| } | |
| _def(varKind, nameOrPrefix, rhs, constant) { | |
| const name = this._scope.toName(nameOrPrefix); | |
| if (rhs !== undefined && constant) | |
| this._constants[name.str] = rhs; | |
| this._leafNode(new Def(varKind, name, rhs)); | |
| return name; | |
| } | |
| // `const` declaration (`var` in es5 mode) | |
| const(nameOrPrefix, rhs, _constant) { | |
| return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); | |
| } | |
| // `let` declaration with optional assignment (`var` in es5 mode) | |
| let(nameOrPrefix, rhs, _constant) { | |
| return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); | |
| } | |
| // `var` declaration with optional assignment | |
| var(nameOrPrefix, rhs, _constant) { | |
| return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); | |
| } | |
| // assignment code | |
| assign(lhs, rhs, sideEffects) { | |
| return this._leafNode(new Assign(lhs, rhs, sideEffects)); | |
| } | |
| // `+=` code | |
| add(lhs, rhs) { | |
| return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs)); | |
| } | |
| // appends passed SafeExpr to code or executes Block | |
| code(c) { | |
| if (typeof c == "function") | |
| c(); | |
| else if (c !== code_1.nil) | |
| this._leafNode(new AnyCode(c)); | |
| return this; | |
| } | |
| // returns code for object literal for the passed argument list of key-value pairs | |
| object(...keyValues) { | |
| const code = ["{"]; | |
| for (const [key, value] of keyValues) { | |
| if (code.length > 1) | |
| code.push(","); | |
| code.push(key); | |
| if (key !== value || this.opts.es5) { | |
| code.push(":"); | |
| (0, code_1.addCodeArg)(code, value); | |
| } | |
| } | |
| code.push("}"); | |
| return new code_1._Code(code); | |
| } | |
| // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) | |
| if(condition, thenBody, elseBody) { | |
| this._blockNode(new If(condition)); | |
| if (thenBody && elseBody) { | |
| this.code(thenBody).else().code(elseBody).endIf(); | |
| } | |
| else if (thenBody) { | |
| this.code(thenBody).endIf(); | |
| } | |
| else if (elseBody) { | |
| throw new Error('CodeGen: "else" body without "then" body'); | |
| } | |
| return this; | |
| } | |
| // `else if` clause - invalid without `if` or after `else` clauses | |
| elseIf(condition) { | |
| return this._elseNode(new If(condition)); | |
| } | |
| // `else` clause - only valid after `if` or `else if` clauses | |
| else() { | |
| return this._elseNode(new Else()); | |
| } | |
| // end `if` statement (needed if gen.if was used only with condition) | |
| endIf() { | |
| return this._endBlockNode(If, Else); | |
| } | |
| _for(node, forBody) { | |
| this._blockNode(node); | |
| if (forBody) | |
| this.code(forBody).endFor(); | |
| return this; | |
| } | |
| // a generic `for` clause (or statement if `forBody` is passed) | |
| for(iteration, forBody) { | |
| return this._for(new ForLoop(iteration), forBody); | |
| } | |
| // `for` statement for a range of values | |
| forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { | |
| const name = this._scope.toName(nameOrPrefix); | |
| return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); | |
| } | |
| // `for-of` statement (in es5 mode replace with a normal for loop) | |
| forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { | |
| const name = this._scope.toName(nameOrPrefix); | |
| if (this.opts.es5) { | |
| const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable); | |
| return this.forRange("_i", 0, (0, code_1._) `${arr}.length`, (i) => { | |
| this.var(name, (0, code_1._) `${arr}[${i}]`); | |
| forBody(name); | |
| }); | |
| } | |
| return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); | |
| } | |
| // `for-in` statement. | |
| // With option `ownProperties` replaced with a `for-of` loop for object keys | |
| forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { | |
| if (this.opts.ownProperties) { | |
| return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody); | |
| } | |
| const name = this._scope.toName(nameOrPrefix); | |
| return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); | |
| } | |
| // end `for` loop | |
| endFor() { | |
| return this._endBlockNode(For); | |
| } | |
| // `label` statement | |
| label(label) { | |
| return this._leafNode(new Label(label)); | |
| } | |
| // `break` statement | |
| break(label) { | |
| return this._leafNode(new Break(label)); | |
| } | |
| // `return` statement | |
| return(value) { | |
| const node = new Return(); | |
| this._blockNode(node); | |
| this.code(value); | |
| if (node.nodes.length !== 1) | |
| throw new Error('CodeGen: "return" should have one node'); | |
| return this._endBlockNode(Return); | |
| } | |
| // `try` statement | |
| try(tryBody, catchCode, finallyCode) { | |
| if (!catchCode && !finallyCode) | |
| throw new Error('CodeGen: "try" without "catch" and "finally"'); | |
| const node = new Try(); | |
| this._blockNode(node); | |
| this.code(tryBody); | |
| if (catchCode) { | |
| const error = this.name("e"); | |
| this._currNode = node.catch = new Catch(error); | |
| catchCode(error); | |
| } | |
| if (finallyCode) { | |
| this._currNode = node.finally = new Finally(); | |
| this.code(finallyCode); | |
| } | |
| return this._endBlockNode(Catch, Finally); | |
| } | |
| // `throw` statement | |
| throw(error) { | |
| return this._leafNode(new Throw(error)); | |
| } | |
| // start self-balancing block | |
| block(body, nodeCount) { | |
| this._blockStarts.push(this._nodes.length); | |
| if (body) | |
| this.code(body).endBlock(nodeCount); | |
| return this; | |
| } | |
| // end the current self-balancing block | |
| endBlock(nodeCount) { | |
| const len = this._blockStarts.pop(); | |
| if (len === undefined) | |
| throw new Error("CodeGen: not in self-balancing block"); | |
| const toClose = this._nodes.length - len; | |
| if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) { | |
| throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); | |
| } | |
| this._nodes.length = len; | |
| return this; | |
| } | |
| // `function` heading (or definition if funcBody is passed) | |
| func(name, args = code_1.nil, async, funcBody) { | |
| this._blockNode(new Func(name, args, async)); | |
| if (funcBody) | |
| this.code(funcBody).endFunc(); | |
| return this; | |
| } | |
| // end function definition | |
| endFunc() { | |
| return this._endBlockNode(Func); | |
| } | |
| optimize(n = 1) { | |
| while (n-- > 0) { | |
| this._root.optimizeNodes(); | |
| this._root.optimizeNames(this._root.names, this._constants); | |
| } | |
| } | |
| _leafNode(node) { | |
| this._currNode.nodes.push(node); | |
| return this; | |
| } | |
| _blockNode(node) { | |
| this._currNode.nodes.push(node); | |
| this._nodes.push(node); | |
| } | |
| _endBlockNode(N1, N2) { | |
| const n = this._currNode; | |
| if (n instanceof N1 || (N2 && n instanceof N2)) { | |
| this._nodes.pop(); | |
| return this; | |
| } | |
| throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`); | |
| } | |
| _elseNode(node) { | |
| const n = this._currNode; | |
| if (!(n instanceof If)) { | |
| throw new Error('CodeGen: "else" without "if"'); | |
| } | |
| this._currNode = n.else = node; | |
| return this; | |
| } | |
| get _root() { | |
| return this._nodes[0]; | |
| } | |
| get _currNode() { | |
| const ns = this._nodes; | |
| return ns[ns.length - 1]; | |
| } | |
| set _currNode(node) { | |
| const ns = this._nodes; | |
| ns[ns.length - 1] = node; | |
| } | |
| } | |
| exports.CodeGen = CodeGen; | |
| function addNames(names, from) { | |
| for (const n in from) | |
| names[n] = (names[n] || 0) + (from[n] || 0); | |
| return names; | |
| } | |
| function addExprNames(names, from) { | |
| return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names; | |
| } | |
| function optimizeExpr(expr, names, constants) { | |
| if (expr instanceof code_1.Name) | |
| return replaceName(expr); | |
| if (!canOptimize(expr)) | |
| return expr; | |
| return new code_1._Code(expr._items.reduce((items, c) => { | |
| if (c instanceof code_1.Name) | |
| c = replaceName(c); | |
| if (c instanceof code_1._Code) | |
| items.push(...c._items); | |
| else | |
| items.push(c); | |
| return items; | |
| }, [])); | |
| function replaceName(n) { | |
| const c = constants[n.str]; | |
| if (c === undefined || names[n.str] !== 1) | |
| return n; | |
| delete names[n.str]; | |
| return c; | |
| } | |
| function canOptimize(e) { | |
| return (e instanceof code_1._Code && | |
| e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined)); | |
| } | |
| } | |
| function subtractNames(names, from) { | |
| for (const n in from) | |
| names[n] = (names[n] || 0) - (from[n] || 0); | |
| } | |
| function not(x) { | |
| return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._) `!${par(x)}`; | |
| } | |
| exports.not = not; | |
| const andCode = mappend(exports.operators.AND); | |
| // boolean AND (&&) expression with the passed arguments | |
| function and(...args) { | |
| return args.reduce(andCode); | |
| } | |
| exports.and = and; | |
| const orCode = mappend(exports.operators.OR); | |
| // boolean OR (||) expression with the passed arguments | |
| function or(...args) { | |
| return args.reduce(orCode); | |
| } | |
| exports.or = or; | |
| function mappend(op) { | |
| return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`); | |
| } | |
| function par(x) { | |
| return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`; | |
| } | |
| //# sourceMappingURL=index.js.map |