@cartanova/qgrid-cli 2.6.11 → 2.7.1

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js

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