@applitools/mcp 0.4.0 → 0.4.2

package/dist/index.js

@@ -13655,1016 +13655,1037 @@ var codegen = {};
 
 var code$1 = {};
 
-(function (exports$1) {
-	Object.defineProperty(exports$1, "__esModule", { value: true });
-	exports$1.regexpCode = exports$1.getEsmExportName = exports$1.getProperty = exports$1.safeStringify = exports$1.stringify = exports$1.strConcat = exports$1.addCodeArg = exports$1.str = exports$1._ = exports$1.nil = exports$1._Code = exports$1.Name = exports$1.IDENTIFIER = exports$1._CodeOrName = void 0;
-	// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-	class _CodeOrName {
-	}
-	exports$1._CodeOrName = _CodeOrName;
-	exports$1.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
-	class Name extends _CodeOrName {
-	    constructor(s) {
-	        super();
-	        if (!exports$1.IDENTIFIER.test(s))
-	            throw new Error("CodeGen: name must be a valid identifier");
-	        this.str = s;
-	    }
-	    toString() {
-	        return this.str;
-	    }
-	    emptyStr() {
-	        return false;
-	    }
-	    get names() {
-	        return { [this.str]: 1 };
-	    }
-	}
-	exports$1.Name = Name;
-	class _Code extends _CodeOrName {
-	    constructor(code) {
-	        super();
-	        this._items = typeof code === "string" ? [code] : code;
-	    }
-	    toString() {
-	        return this.str;
-	    }
-	    emptyStr() {
-	        if (this._items.length > 1)
-	            return false;
-	        const item = this._items[0];
-	        return item === "" || item === '""';
-	    }
-	    get str() {
-	        var _a;
-	        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, "")));
-	    }
-	    get names() {
-	        var _a;
-	        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {
-	            if (c instanceof Name)
-	                names[c.str] = (names[c.str] || 0) + 1;
-	            return names;
-	        }, {})));
-	    }
-	}
-	exports$1._Code = _Code;
-	exports$1.nil = new _Code("");
-	function _(strs, ...args) {
-	    const code = [strs[0]];
-	    let i = 0;
-	    while (i < args.length) {
-	        addCodeArg(code, args[i]);
-	        code.push(strs[++i]);
-	    }
-	    return new _Code(code);
-	}
-	exports$1._ = _;
-	const plus = new _Code("+");
-	function str(strs, ...args) {
-	    const expr = [safeStringify(strs[0])];
-	    let i = 0;
-	    while (i < args.length) {
-	        expr.push(plus);
-	        addCodeArg(expr, args[i]);
-	        expr.push(plus, safeStringify(strs[++i]));
-	    }
-	    optimize(expr);
-	    return new _Code(expr);
-	}
-	exports$1.str = str;
-	function addCodeArg(code, arg) {
-	    if (arg instanceof _Code)
-	        code.push(...arg._items);
-	    else if (arg instanceof Name)
-	        code.push(arg);
-	    else
-	        code.push(interpolate(arg));
-	}
-	exports$1.addCodeArg = addCodeArg;
-	function optimize(expr) {
-	    let i = 1;
-	    while (i < expr.length - 1) {
-	        if (expr[i] === plus) {
-	            const res = mergeExprItems(expr[i - 1], expr[i + 1]);
-	            if (res !== undefined) {
-	                expr.splice(i - 1, 3, res);
-	                continue;
-	            }
-	            expr[i++] = "+";
-	        }
-	        i++;
-	    }
-	}
-	function mergeExprItems(a, b) {
-	    if (b === '""')
-	        return a;
-	    if (a === '""')
-	        return b;
-	    if (typeof a == "string") {
-	        if (b instanceof Name || a[a.length - 1] !== '"')
-	            return;
-	        if (typeof b != "string")
-	            return `${a.slice(0, -1)}${b}"`;
-	        if (b[0] === '"')
-	            return a.slice(0, -1) + b.slice(1);
-	        return;
-	    }
-	    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
-	        return `"${a}${b.slice(1)}`;
-	    return;
-	}
-	function strConcat(c1, c2) {
-	    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;
-	}
-	exports$1.strConcat = strConcat;
-	// TODO do not allow arrays here
-	function interpolate(x) {
-	    return typeof x == "number" || typeof x == "boolean" || x === null
-	        ? x
-	        : safeStringify(Array.isArray(x) ? x.join(",") : x);
-	}
-	function stringify(x) {
-	    return new _Code(safeStringify(x));
-	}
-	exports$1.stringify = stringify;
-	function safeStringify(x) {
-	    return JSON.stringify(x)
-	        .replace(/\u2028/g, "\\u2028")
-	        .replace(/\u2029/g, "\\u2029");
-	}
-	exports$1.safeStringify = safeStringify;
-	function getProperty(key) {
-	    return typeof key == "string" && exports$1.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;
-	}
-	exports$1.getProperty = getProperty;
-	//Does best effort to format the name properly
-	function getEsmExportName(key) {
-	    if (typeof key == "string" && exports$1.IDENTIFIER.test(key)) {
-	        return new _Code(`${key}`);
-	    }
-	    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
-	}
-	exports$1.getEsmExportName = getEsmExportName;
-	function regexpCode(rx) {
-	    return new _Code(rx.toString());
-	}
-	exports$1.regexpCode = regexpCode;
-	
-} (code$1));
+var hasRequiredCode$1;
+
+function requireCode$1 () {
+	if (hasRequiredCode$1) return code$1;
+	hasRequiredCode$1 = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.regexpCode = exports$1.getEsmExportName = exports$1.getProperty = exports$1.safeStringify = exports$1.stringify = exports$1.strConcat = exports$1.addCodeArg = exports$1.str = exports$1._ = exports$1.nil = exports$1._Code = exports$1.Name = exports$1.IDENTIFIER = exports$1._CodeOrName = void 0;
+		// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+		class _CodeOrName {
+		}
+		exports$1._CodeOrName = _CodeOrName;
+		exports$1.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+		class Name extends _CodeOrName {
+		    constructor(s) {
+		        super();
+		        if (!exports$1.IDENTIFIER.test(s))
+		            throw new Error("CodeGen: name must be a valid identifier");
+		        this.str = s;
+		    }
+		    toString() {
+		        return this.str;
+		    }
+		    emptyStr() {
+		        return false;
+		    }
+		    get names() {
+		        return { [this.str]: 1 };
+		    }
+		}
+		exports$1.Name = Name;
+		class _Code extends _CodeOrName {
+		    constructor(code) {
+		        super();
+		        this._items = typeof code === "string" ? [code] : code;
+		    }
+		    toString() {
+		        return this.str;
+		    }
+		    emptyStr() {
+		        if (this._items.length > 1)
+		            return false;
+		        const item = this._items[0];
+		        return item === "" || item === '""';
+		    }
+		    get str() {
+		        var _a;
+		        return ((_a = this._str) !== null && _a !== void 0 ? _a : (this._str = this._items.reduce((s, c) => `${s}${c}`, "")));
+		    }
+		    get names() {
+		        var _a;
+		        return ((_a = this._names) !== null && _a !== void 0 ? _a : (this._names = this._items.reduce((names, c) => {
+		            if (c instanceof Name)
+		                names[c.str] = (names[c.str] || 0) + 1;
+		            return names;
+		        }, {})));
+		    }
+		}
+		exports$1._Code = _Code;
+		exports$1.nil = new _Code("");
+		function _(strs, ...args) {
+		    const code = [strs[0]];
+		    let i = 0;
+		    while (i < args.length) {
+		        addCodeArg(code, args[i]);
+		        code.push(strs[++i]);
+		    }
+		    return new _Code(code);
+		}
+		exports$1._ = _;
+		const plus = new _Code("+");
+		function str(strs, ...args) {
+		    const expr = [safeStringify(strs[0])];
+		    let i = 0;
+		    while (i < args.length) {
+		        expr.push(plus);
+		        addCodeArg(expr, args[i]);
+		        expr.push(plus, safeStringify(strs[++i]));
+		    }
+		    optimize(expr);
+		    return new _Code(expr);
+		}
+		exports$1.str = str;
+		function addCodeArg(code, arg) {
+		    if (arg instanceof _Code)
+		        code.push(...arg._items);
+		    else if (arg instanceof Name)
+		        code.push(arg);
+		    else
+		        code.push(interpolate(arg));
+		}
+		exports$1.addCodeArg = addCodeArg;
+		function optimize(expr) {
+		    let i = 1;
+		    while (i < expr.length - 1) {
+		        if (expr[i] === plus) {
+		            const res = mergeExprItems(expr[i - 1], expr[i + 1]);
+		            if (res !== undefined) {
+		                expr.splice(i - 1, 3, res);
+		                continue;
+		            }
+		            expr[i++] = "+";
+		        }
+		        i++;
+		    }
+		}
+		function mergeExprItems(a, b) {
+		    if (b === '""')
+		        return a;
+		    if (a === '""')
+		        return b;
+		    if (typeof a == "string") {
+		        if (b instanceof Name || a[a.length - 1] !== '"')
+		            return;
+		        if (typeof b != "string")
+		            return `${a.slice(0, -1)}${b}"`;
+		        if (b[0] === '"')
+		            return a.slice(0, -1) + b.slice(1);
+		        return;
+		    }
+		    if (typeof b == "string" && b[0] === '"' && !(a instanceof Name))
+		        return `"${a}${b.slice(1)}`;
+		    return;
+		}
+		function strConcat(c1, c2) {
+		    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str `${c1}${c2}`;
+		}
+		exports$1.strConcat = strConcat;
+		// TODO do not allow arrays here
+		function interpolate(x) {
+		    return typeof x == "number" || typeof x == "boolean" || x === null
+		        ? x
+		        : safeStringify(Array.isArray(x) ? x.join(",") : x);
+		}
+		function stringify(x) {
+		    return new _Code(safeStringify(x));
+		}
+		exports$1.stringify = stringify;
+		function safeStringify(x) {
+		    return JSON.stringify(x)
+		        .replace(/\u2028/g, "\\u2028")
+		        .replace(/\u2029/g, "\\u2029");
+		}
+		exports$1.safeStringify = safeStringify;
+		function getProperty(key) {
+		    return typeof key == "string" && exports$1.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _ `[${key}]`;
+		}
+		exports$1.getProperty = getProperty;
+		//Does best effort to format the name properly
+		function getEsmExportName(key) {
+		    if (typeof key == "string" && exports$1.IDENTIFIER.test(key)) {
+		        return new _Code(`${key}`);
+		    }
+		    throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+		}
+		exports$1.getEsmExportName = getEsmExportName;
+		function regexpCode(rx) {
+		    return new _Code(rx.toString());
+		}
+		exports$1.regexpCode = regexpCode;
+		
+	} (code$1));
+	return code$1;
+}
 
 var scope = {};
 
-(function (exports$1) {
-	Object.defineProperty(exports$1, "__esModule", { value: true });
-	exports$1.ValueScope = exports$1.ValueScopeName = exports$1.Scope = exports$1.varKinds = exports$1.UsedValueState = void 0;
-	const code_1 = code$1;
-	class ValueError extends Error {
-	    constructor(name) {
-	        super(`CodeGen: "code" for ${name} not defined`);
-	        this.value = name.value;
-	    }
-	}
-	var UsedValueState;
-	(function (UsedValueState) {
-	    UsedValueState[UsedValueState["Started"] = 0] = "Started";
-	    UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
-	})(UsedValueState || (exports$1.UsedValueState = UsedValueState = {}));
-	exports$1.varKinds = {
-	    const: new code_1.Name("const"),
-	    let: new code_1.Name("let"),
-	    var: new code_1.Name("var"),
-	};
-	class Scope {
-	    constructor({ prefixes, parent } = {}) {
-	        this._names = {};
-	        this._prefixes = prefixes;
-	        this._parent = parent;
-	    }
-	    toName(nameOrPrefix) {
-	        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
-	    }
-	    name(prefix) {
-	        return new code_1.Name(this._newName(prefix));
-	    }
-	    _newName(prefix) {
-	        const ng = this._names[prefix] || this._nameGroup(prefix);
-	        return `${prefix}${ng.index++}`;
-	    }
-	    _nameGroup(prefix) {
-	        var _a, _b;
-	        if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) {
-	            throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
-	        }
-	        return (this._names[prefix] = { prefix, index: 0 });
-	    }
-	}
-	exports$1.Scope = Scope;
-	class ValueScopeName extends code_1.Name {
-	    constructor(prefix, nameStr) {
-	        super(nameStr);
-	        this.prefix = prefix;
-	    }
-	    setValue(value, { property, itemIndex }) {
-	        this.value = value;
-	        this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`;
-	    }
-	}
-	exports$1.ValueScopeName = ValueScopeName;
-	const line = (0, code_1._) `\n`;
-	class ValueScope extends Scope {
-	    constructor(opts) {
-	        super(opts);
-	        this._values = {};
-	        this._scope = opts.scope;
-	        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
-	    }
-	    get() {
-	        return this._scope;
-	    }
-	    name(prefix) {
-	        return new ValueScopeName(prefix, this._newName(prefix));
-	    }
-	    value(nameOrPrefix, value) {
-	        var _a;
-	        if (value.ref === undefined)
-	            throw new Error("CodeGen: ref must be passed in value");
-	        const name = this.toName(nameOrPrefix);
-	        const { prefix } = name;
-	        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
-	        let vs = this._values[prefix];
-	        if (vs) {
-	            const _name = vs.get(valueKey);
-	            if (_name)
-	                return _name;
-	        }
-	        else {
-	            vs = this._values[prefix] = new Map();
-	        }
-	        vs.set(valueKey, name);
-	        const s = this._scope[prefix] || (this._scope[prefix] = []);
-	        const itemIndex = s.length;
-	        s[itemIndex] = value.ref;
-	        name.setValue(value, { property: prefix, itemIndex });
-	        return name;
-	    }
-	    getValue(prefix, keyOrRef) {
-	        const vs = this._values[prefix];
-	        if (!vs)
-	            return;
-	        return vs.get(keyOrRef);
-	    }
-	    scopeRefs(scopeName, values = this._values) {
-	        return this._reduceValues(values, (name) => {
-	            if (name.scopePath === undefined)
-	                throw new Error(`CodeGen: name "${name}" has no value`);
-	            return (0, code_1._) `${scopeName}${name.scopePath}`;
-	        });
-	    }
-	    scopeCode(values = this._values, usedValues, getCode) {
-	        return this._reduceValues(values, (name) => {
-	            if (name.value === undefined)
-	                throw new Error(`CodeGen: name "${name}" has no value`);
-	            return name.value.code;
-	        }, usedValues, getCode);
-	    }
-	    _reduceValues(values, valueCode, usedValues = {}, getCode) {
-	        let code = code_1.nil;
-	        for (const prefix in values) {
-	            const vs = values[prefix];
-	            if (!vs)
-	                continue;
-	            const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map());
-	            vs.forEach((name) => {
-	                if (nameSet.has(name))
-	                    return;
-	                nameSet.set(name, UsedValueState.Started);
-	                let c = valueCode(name);
-	                if (c) {
-	                    const def = this.opts.es5 ? exports$1.varKinds.var : exports$1.varKinds.const;
-	                    code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`;
-	                }
-	                else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) {
-	                    code = (0, code_1._) `${code}${c}${this.opts._n}`;
-	                }
-	                else {
-	                    throw new ValueError(name);
-	                }
-	                nameSet.set(name, UsedValueState.Completed);
-	            });
-	        }
-	        return code;
-	    }
-	}
-	exports$1.ValueScope = ValueScope;
-	
-} (scope));
+var hasRequiredScope;
 
-(function (exports$1) {
-	Object.defineProperty(exports$1, "__esModule", { value: true });
-	exports$1.or = exports$1.and = exports$1.not = exports$1.CodeGen = exports$1.operators = exports$1.varKinds = exports$1.ValueScopeName = exports$1.ValueScope = exports$1.Scope = exports$1.Name = exports$1.regexpCode = exports$1.stringify = exports$1.getProperty = exports$1.nil = exports$1.strConcat = exports$1.str = exports$1._ = void 0;
-	const code_1 = code$1;
-	const scope_1 = scope;
-	var code_2 = code$1;
-	Object.defineProperty(exports$1, "_", { enumerable: true, get: function () { return code_2._; } });
-	Object.defineProperty(exports$1, "str", { enumerable: true, get: function () { return code_2.str; } });
-	Object.defineProperty(exports$1, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } });
-	Object.defineProperty(exports$1, "nil", { enumerable: true, get: function () { return code_2.nil; } });
-	Object.defineProperty(exports$1, "getProperty", { enumerable: true, get: function () { return code_2.getProperty; } });
-	Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function () { return code_2.stringify; } });
-	Object.defineProperty(exports$1, "regexpCode", { enumerable: true, get: function () { return code_2.regexpCode; } });
-	Object.defineProperty(exports$1, "Name", { enumerable: true, get: function () { return code_2.Name; } });
-	var scope_2 = scope;
-	Object.defineProperty(exports$1, "Scope", { enumerable: true, get: function () { return scope_2.Scope; } });
-	Object.defineProperty(exports$1, "ValueScope", { enumerable: true, get: function () { return scope_2.ValueScope; } });
-	Object.defineProperty(exports$1, "ValueScopeName", { enumerable: true, get: function () { return scope_2.ValueScopeName; } });
-	Object.defineProperty(exports$1, "varKinds", { enumerable: true, get: function () { return scope_2.varKinds; } });
-	exports$1.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$1.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$1.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$1.not = not;
-	const andCode = mappend(exports$1.operators.AND);
-	// boolean AND (&&) expression with the passed arguments
-	function and(...args) {
-	    return args.reduce(andCode);
-	}
-	exports$1.and = and;
-	const orCode = mappend(exports$1.operators.OR);
-	// boolean OR (||) expression with the passed arguments
-	function or(...args) {
-	    return args.reduce(orCode);
-	}
-	exports$1.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})`;
-	}
-	
-} (codegen));
+function requireScope () {
+	if (hasRequiredScope) return scope;
+	hasRequiredScope = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.ValueScope = exports$1.ValueScopeName = exports$1.Scope = exports$1.varKinds = exports$1.UsedValueState = void 0;
+		const code_1 = requireCode$1();
+		class ValueError extends Error {
+		    constructor(name) {
+		        super(`CodeGen: "code" for ${name} not defined`);
+		        this.value = name.value;
+		    }
+		}
+		var UsedValueState;
+		(function (UsedValueState) {
+		    UsedValueState[UsedValueState["Started"] = 0] = "Started";
+		    UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
+		})(UsedValueState || (exports$1.UsedValueState = UsedValueState = {}));
+		exports$1.varKinds = {
+		    const: new code_1.Name("const"),
+		    let: new code_1.Name("let"),
+		    var: new code_1.Name("var"),
+		};
+		class Scope {
+		    constructor({ prefixes, parent } = {}) {
+		        this._names = {};
+		        this._prefixes = prefixes;
+		        this._parent = parent;
+		    }
+		    toName(nameOrPrefix) {
+		        return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
+		    }
+		    name(prefix) {
+		        return new code_1.Name(this._newName(prefix));
+		    }
+		    _newName(prefix) {
+		        const ng = this._names[prefix] || this._nameGroup(prefix);
+		        return `${prefix}${ng.index++}`;
+		    }
+		    _nameGroup(prefix) {
+		        var _a, _b;
+		        if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || (this._prefixes && !this._prefixes.has(prefix))) {
+		            throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
+		        }
+		        return (this._names[prefix] = { prefix, index: 0 });
+		    }
+		}
+		exports$1.Scope = Scope;
+		class ValueScopeName extends code_1.Name {
+		    constructor(prefix, nameStr) {
+		        super(nameStr);
+		        this.prefix = prefix;
+		    }
+		    setValue(value, { property, itemIndex }) {
+		        this.value = value;
+		        this.scopePath = (0, code_1._) `.${new code_1.Name(property)}[${itemIndex}]`;
+		    }
+		}
+		exports$1.ValueScopeName = ValueScopeName;
+		const line = (0, code_1._) `\n`;
+		class ValueScope extends Scope {
+		    constructor(opts) {
+		        super(opts);
+		        this._values = {};
+		        this._scope = opts.scope;
+		        this.opts = { ...opts, _n: opts.lines ? line : code_1.nil };
+		    }
+		    get() {
+		        return this._scope;
+		    }
+		    name(prefix) {
+		        return new ValueScopeName(prefix, this._newName(prefix));
+		    }
+		    value(nameOrPrefix, value) {
+		        var _a;
+		        if (value.ref === undefined)
+		            throw new Error("CodeGen: ref must be passed in value");
+		        const name = this.toName(nameOrPrefix);
+		        const { prefix } = name;
+		        const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
+		        let vs = this._values[prefix];
+		        if (vs) {
+		            const _name = vs.get(valueKey);
+		            if (_name)
+		                return _name;
+		        }
+		        else {
+		            vs = this._values[prefix] = new Map();
+		        }
+		        vs.set(valueKey, name);
+		        const s = this._scope[prefix] || (this._scope[prefix] = []);
+		        const itemIndex = s.length;
+		        s[itemIndex] = value.ref;
+		        name.setValue(value, { property: prefix, itemIndex });
+		        return name;
+		    }
+		    getValue(prefix, keyOrRef) {
+		        const vs = this._values[prefix];
+		        if (!vs)
+		            return;
+		        return vs.get(keyOrRef);
+		    }
+		    scopeRefs(scopeName, values = this._values) {
+		        return this._reduceValues(values, (name) => {
+		            if (name.scopePath === undefined)
+		                throw new Error(`CodeGen: name "${name}" has no value`);
+		            return (0, code_1._) `${scopeName}${name.scopePath}`;
+		        });
+		    }
+		    scopeCode(values = this._values, usedValues, getCode) {
+		        return this._reduceValues(values, (name) => {
+		            if (name.value === undefined)
+		                throw new Error(`CodeGen: name "${name}" has no value`);
+		            return name.value.code;
+		        }, usedValues, getCode);
+		    }
+		    _reduceValues(values, valueCode, usedValues = {}, getCode) {
+		        let code = code_1.nil;
+		        for (const prefix in values) {
+		            const vs = values[prefix];
+		            if (!vs)
+		                continue;
+		            const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map());
+		            vs.forEach((name) => {
+		                if (nameSet.has(name))
+		                    return;
+		                nameSet.set(name, UsedValueState.Started);
+		                let c = valueCode(name);
+		                if (c) {
+		                    const def = this.opts.es5 ? exports$1.varKinds.var : exports$1.varKinds.const;
+		                    code = (0, code_1._) `${code}${def} ${name} = ${c};${this.opts._n}`;
+		                }
+		                else if ((c = getCode === null || getCode === void 0 ? void 0 : getCode(name))) {
+		                    code = (0, code_1._) `${code}${c}${this.opts._n}`;
+		                }
+		                else {
+		                    throw new ValueError(name);
+		                }
+		                nameSet.set(name, UsedValueState.Completed);
+		            });
+		        }
+		        return code;
+		    }
+		}
+		exports$1.ValueScope = ValueScope;
+		
+	} (scope));
+	return scope;
+}
+
+var hasRequiredCodegen;
+
+function requireCodegen () {
+	if (hasRequiredCodegen) return codegen;
+	hasRequiredCodegen = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.or = exports$1.and = exports$1.not = exports$1.CodeGen = exports$1.operators = exports$1.varKinds = exports$1.ValueScopeName = exports$1.ValueScope = exports$1.Scope = exports$1.Name = exports$1.regexpCode = exports$1.stringify = exports$1.getProperty = exports$1.nil = exports$1.strConcat = exports$1.str = exports$1._ = void 0;
+		const code_1 = requireCode$1();
+		const scope_1 = requireScope();
+		var code_2 = requireCode$1();
+		Object.defineProperty(exports$1, "_", { enumerable: true, get: function () { return code_2._; } });
+		Object.defineProperty(exports$1, "str", { enumerable: true, get: function () { return code_2.str; } });
+		Object.defineProperty(exports$1, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } });
+		Object.defineProperty(exports$1, "nil", { enumerable: true, get: function () { return code_2.nil; } });
+		Object.defineProperty(exports$1, "getProperty", { enumerable: true, get: function () { return code_2.getProperty; } });
+		Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function () { return code_2.stringify; } });
+		Object.defineProperty(exports$1, "regexpCode", { enumerable: true, get: function () { return code_2.regexpCode; } });
+		Object.defineProperty(exports$1, "Name", { enumerable: true, get: function () { return code_2.Name; } });
+		var scope_2 = requireScope();
+		Object.defineProperty(exports$1, "Scope", { enumerable: true, get: function () { return scope_2.Scope; } });
+		Object.defineProperty(exports$1, "ValueScope", { enumerable: true, get: function () { return scope_2.ValueScope; } });
+		Object.defineProperty(exports$1, "ValueScopeName", { enumerable: true, get: function () { return scope_2.ValueScopeName; } });
+		Object.defineProperty(exports$1, "varKinds", { enumerable: true, get: function () { return scope_2.varKinds; } });
+		exports$1.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$1.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$1.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$1.not = not;
+		const andCode = mappend(exports$1.operators.AND);
+		// boolean AND (&&) expression with the passed arguments
+		function and(...args) {
+		    return args.reduce(andCode);
+		}
+		exports$1.and = and;
+		const orCode = mappend(exports$1.operators.OR);
+		// boolean OR (||) expression with the passed arguments
+		function or(...args) {
+		    return args.reduce(orCode);
+		}
+		exports$1.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})`;
+		}
+		
+	} (codegen));
+	return codegen;
+}
 
 var util = {};
 
 Object.defineProperty(util, "__esModule", { value: true });
 util.checkStrictMode = util.getErrorPath = util.Type = util.useFunc = util.setEvaluated = util.evaluatedPropsToName = util.mergeEvaluated = util.eachItem = util.unescapeJsonPointer = util.escapeJsonPointer = util.escapeFragment = util.unescapeFragment = util.schemaRefOrVal = util.schemaHasRulesButRef = util.schemaHasRules = util.checkUnknownRules = util.alwaysValidSchema = util.toHash = void 0;
-const codegen_1$o = codegen;
-const code_1$9 = code$1;
+const codegen_1$o = requireCodegen();
+const code_1$9 = requireCode$1();
 // TODO refactor to use Set
 function toHash(arr) {
     const hash = {};
@@ -14846,7 +14867,7 @@ function requireNames () {
 	if (hasRequiredNames) return names;
 	hasRequiredNames = 1;
 	Object.defineProperty(names, "__esModule", { value: true });
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const names$1 = {
 	    // validation function arguments
 	    data: new codegen_1.Name("data"), // data passed to validation function
@@ -14883,7 +14904,7 @@ function requireErrors () {
 	(function (exports$1) {
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		exports$1.extendErrors = exports$1.resetErrorsCount = exports$1.reportExtraError = exports$1.reportError = exports$1.keyword$DataError = exports$1.keywordError = void 0;
-		const codegen_1 = codegen;
+		const codegen_1 = requireCodegen();
 		const util_1 = util;
 		const names_1 = requireNames();
 		exports$1.keywordError = {
@@ -15015,7 +15036,7 @@ function requireBoolSchema () {
 	Object.defineProperty(boolSchema, "__esModule", { value: true });
 	boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
 	const errors_1 = requireErrors();
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const names_1 = requireNames();
 	const boolError = {
 	    message: "boolean schema is false",
@@ -15126,7 +15147,7 @@ dataType.reportTypeError = dataType.checkDataTypes = dataType.checkDataType = da
 const rules_1 = rules;
 const applicability_1 = requireApplicability();
 const errors_1 = requireErrors();
-const codegen_1$n = codegen;
+const codegen_1$n = requireCodegen();
 const util_1$m = util;
 var DataType;
 (function (DataType) {
@@ -15332,7 +15353,7 @@ function requireDefaults () {
 	hasRequiredDefaults = 1;
 	Object.defineProperty(defaults, "__esModule", { value: true });
 	defaults.assignDefaults = void 0;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const util_1 = util;
 	function assignDefaults(it, ty) {
 	    const { properties, items } = it.schema;
@@ -15378,7 +15399,7 @@ function requireCode () {
 	hasRequiredCode = 1;
 	Object.defineProperty(code, "__esModule", { value: true });
 	code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const util_1 = util;
 	const names_1 = requireNames();
 	const util_2 = util;
@@ -15516,7 +15537,7 @@ function requireKeyword () {
 	hasRequiredKeyword = 1;
 	Object.defineProperty(keyword, "__esModule", { value: true });
 	keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const names_1 = requireNames();
 	const code_1 = requireCode();
 	const errors_1 = requireErrors();
@@ -15649,7 +15670,7 @@ function requireSubschema () {
 	hasRequiredSubschema = 1;
 	Object.defineProperty(subschema, "__esModule", { value: true });
 	subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const util_1 = util;
 	function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
 	    if (keyword !== undefined && schema !== undefined) {
@@ -16041,7 +16062,7 @@ function requireValidate () {
 	const defaults_1 = requireDefaults();
 	const keyword_1 = requireKeyword();
 	const subschema_1 = requireSubschema();
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const names_1 = requireNames();
 	const resolve_1 = resolve$2;
 	const util_1 = util;
@@ -16598,7 +16619,7 @@ var compile = {};
 
 Object.defineProperty(compile, "__esModule", { value: true });
 compile.resolveSchema = compile.getCompilingSchema = compile.resolveRef = compile.compileSchema = compile.SchemaEnv = void 0;
-const codegen_1$m = codegen;
+const codegen_1$m = requireCodegen();
 const validation_error_1 = requireValidation_error();
 const names_1$2 = requireNames();
 const resolve_1 = resolve$2;
@@ -17644,7 +17665,7 @@ uri$1.default = uri;
 	exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = void 0;
 	var validate_1 = requireValidate();
 	Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
-	var codegen_1 = codegen;
+	var codegen_1 = requireCodegen();
 	Object.defineProperty(exports$1, "_", { enumerable: true, get: function () { return codegen_1._; } });
 	Object.defineProperty(exports$1, "str", { enumerable: true, get: function () { return codegen_1.str; } });
 	Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
@@ -17655,7 +17676,7 @@ uri$1.default = uri;
 	const ref_error_1 = requireRef_error();
 	const rules_1 = rules;
 	const compile_1 = compile;
-	const codegen_2 = codegen;
+	const codegen_2 = requireCodegen();
 	const resolve_1 = resolve$2;
 	const dataType_1 = dataType;
 	const util_1 = util;
@@ -18280,7 +18301,7 @@ Object.defineProperty(ref, "__esModule", { value: true });
 ref.callRef = ref.getValidate = void 0;
 const ref_error_1$1 = requireRef_error();
 const code_1$8 = requireCode();
-const codegen_1$l = codegen;
+const codegen_1$l = requireCodegen();
 const names_1$1 = requireNames();
 const compile_1$1 = compile;
 const util_1$j = util;
@@ -18417,7 +18438,7 @@ var validation$1 = {};
 var limitNumber = {};
 
 Object.defineProperty(limitNumber, "__esModule", { value: true });
-const codegen_1$k = codegen;
+const codegen_1$k = requireCodegen();
 const ops = codegen_1$k.operators;
 const KWDs = {
     maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
@@ -18445,7 +18466,7 @@ limitNumber.default = def$q;
 var multipleOf = {};
 
 Object.defineProperty(multipleOf, "__esModule", { value: true });
-const codegen_1$j = codegen;
+const codegen_1$j = requireCodegen();
 const error$h = {
     message: ({ schemaCode }) => (0, codegen_1$j.str) `must be multiple of ${schemaCode}`,
     params: ({ schemaCode }) => (0, codegen_1$j._) `{multipleOf: ${schemaCode}}`,
@@ -18497,7 +18518,7 @@ ucs2length$1.default = ucs2length;
 ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
 
 Object.defineProperty(limitLength, "__esModule", { value: true });
-const codegen_1$i = codegen;
+const codegen_1$i = requireCodegen();
 const util_1$i = util;
 const ucs2length_1 = ucs2length$1;
 const error$g = {
@@ -18526,7 +18547,7 @@ var pattern = {};
 
 Object.defineProperty(pattern, "__esModule", { value: true });
 const code_1$7 = requireCode();
-const codegen_1$h = codegen;
+const codegen_1$h = requireCodegen();
 const error$f = {
     message: ({ schemaCode }) => (0, codegen_1$h.str) `must match pattern "${schemaCode}"`,
     params: ({ schemaCode }) => (0, codegen_1$h._) `{pattern: ${schemaCode}}`,
@@ -18550,7 +18571,7 @@ pattern.default = def$n;
 var limitProperties = {};
 
 Object.defineProperty(limitProperties, "__esModule", { value: true });
-const codegen_1$g = codegen;
+const codegen_1$g = requireCodegen();
 const error$e = {
     message({ keyword, schemaCode }) {
         const comp = keyword === "maxProperties" ? "more" : "fewer";
@@ -18576,7 +18597,7 @@ var required = {};
 
 Object.defineProperty(required, "__esModule", { value: true });
 const code_1$6 = requireCode();
-const codegen_1$f = codegen;
+const codegen_1$f = requireCodegen();
 const util_1$h = util;
 const error$d = {
     message: ({ params: { missingProperty } }) => (0, codegen_1$f.str) `must have required property '${missingProperty}'`,
@@ -18655,7 +18676,7 @@ required.default = def$l;
 var limitItems = {};
 
 Object.defineProperty(limitItems, "__esModule", { value: true });
-const codegen_1$e = codegen;
+const codegen_1$e = requireCodegen();
 const error$c = {
     message({ keyword, schemaCode }) {
         const comp = keyword === "maxItems" ? "more" : "fewer";
@@ -18689,7 +18710,7 @@ equal$1.default = equal;
 
 Object.defineProperty(uniqueItems, "__esModule", { value: true });
 const dataType_1 = dataType;
-const codegen_1$d = codegen;
+const codegen_1$d = requireCodegen();
 const util_1$g = util;
 const equal_1$2 = equal$1;
 const error$b = {
@@ -18753,7 +18774,7 @@ uniqueItems.default = def$j;
 var _const = {};
 
 Object.defineProperty(_const, "__esModule", { value: true });
-const codegen_1$c = codegen;
+const codegen_1$c = requireCodegen();
 const util_1$f = util;
 const equal_1$1 = equal$1;
 const error$a = {
@@ -18779,7 +18800,7 @@ _const.default = def$i;
 var _enum = {};
 
 Object.defineProperty(_enum, "__esModule", { value: true });
-const codegen_1$b = codegen;
+const codegen_1$b = requireCodegen();
 const util_1$e = util;
 const equal_1 = equal$1;
 const error$9 = {
@@ -18863,7 +18884,7 @@ var additionalItems = {};
 
 Object.defineProperty(additionalItems, "__esModule", { value: true });
 additionalItems.validateAdditionalItems = void 0;
-const codegen_1$a = codegen;
+const codegen_1$a = requireCodegen();
 const util_1$d = util;
 const error$8 = {
     message: ({ params: { len } }) => (0, codegen_1$a.str) `must NOT have more than ${len} items`,
@@ -18915,7 +18936,7 @@ var items = {};
 
 Object.defineProperty(items, "__esModule", { value: true });
 items.validateTuple = void 0;
-const codegen_1$9 = codegen;
+const codegen_1$9 = requireCodegen();
 const util_1$c = util;
 const code_1$5 = requireCode();
 const def$f = {
@@ -18978,7 +18999,7 @@ prefixItems.default = def$e;
 var items2020 = {};
 
 Object.defineProperty(items2020, "__esModule", { value: true });
-const codegen_1$8 = codegen;
+const codegen_1$8 = requireCodegen();
 const util_1$b = util;
 const code_1$4 = requireCode();
 const additionalItems_1$1 = additionalItems;
@@ -19009,7 +19030,7 @@ items2020.default = def$d;
 var contains = {};
 
 Object.defineProperty(contains, "__esModule", { value: true });
-const codegen_1$7 = codegen;
+const codegen_1$7 = requireCodegen();
 const util_1$a = util;
 const error$6 = {
     message: ({ params: { min, max } }) => max === undefined
@@ -19107,7 +19128,7 @@ var dependencies$1 = {};
 (function (exports$1) {
 	Object.defineProperty(exports$1, "__esModule", { value: true });
 	exports$1.validateSchemaDeps = exports$1.validatePropertyDeps = exports$1.error = void 0;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const util_1 = util;
 	const code_1 = requireCode();
 	exports$1.error = {
@@ -19194,7 +19215,7 @@ var dependencies$1 = {};
 var propertyNames = {};
 
 Object.defineProperty(propertyNames, "__esModule", { value: true });
-const codegen_1$6 = codegen;
+const codegen_1$6 = requireCodegen();
 const util_1$9 = util;
 const error$5 = {
     message: "property name must be valid",
@@ -19234,7 +19255,7 @@ var additionalProperties = {};
 
 Object.defineProperty(additionalProperties, "__esModule", { value: true });
 const code_1$3 = requireCode();
-const codegen_1$5 = codegen;
+const codegen_1$5 = requireCodegen();
 const names_1 = requireNames();
 const util_1$8 = util;
 const error$4 = {
@@ -19396,7 +19417,7 @@ var patternProperties = {};
 
 Object.defineProperty(patternProperties, "__esModule", { value: true });
 const code_1$1 = requireCode();
-const codegen_1$4 = codegen;
+const codegen_1$4 = requireCodegen();
 const util_1$6 = util;
 const util_2 = util;
 const def$8 = {
@@ -19511,7 +19532,7 @@ anyOf.default = def$6;
 var oneOf = {};
 
 Object.defineProperty(oneOf, "__esModule", { value: true });
-const codegen_1$3 = codegen;
+const codegen_1$3 = requireCodegen();
 const util_1$4 = util;
 const error$3 = {
     message: "must match exactly one schema in oneOf",
@@ -19596,7 +19617,7 @@ allOf.default = def$4;
 var _if = {};
 
 Object.defineProperty(_if, "__esModule", { value: true });
-const codegen_1$2 = codegen;
+const codegen_1$2 = requireCodegen();
 const util_1$2 = util;
 const error$2 = {
     message: ({ params }) => (0, codegen_1$2.str) `must match "${params.ifClause}" schema`,
@@ -19722,7 +19743,7 @@ var format$2 = {};
 var format$1 = {};
 
 Object.defineProperty(format$1, "__esModule", { value: true });
-const codegen_1$1 = codegen;
+const codegen_1$1 = requireCodegen();
 const error$1 = {
     message: ({ schemaCode }) => (0, codegen_1$1.str) `must match format "${schemaCode}"`,
     params: ({ schemaCode }) => (0, codegen_1$1._) `{format: ${schemaCode}}`,
@@ -19865,7 +19886,7 @@ var DiscrError;
 })(DiscrError || (types.DiscrError = DiscrError = {}));
 
 Object.defineProperty(discriminator, "__esModule", { value: true });
-const codegen_1 = codegen;
+const codegen_1 = requireCodegen();
 const types_1 = types;
 const compile_1 = compile;
 const ref_error_1 = requireRef_error();
@@ -20257,7 +20278,7 @@ var require$$3 = {
 	exports$1.default = Ajv;
 	var validate_1 = requireValidate();
 	Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
-	var codegen_1 = codegen;
+	var codegen_1 = requireCodegen();
 	Object.defineProperty(exports$1, "_", { enumerable: true, get: function () { return codegen_1._; } });
 	Object.defineProperty(exports$1, "str", { enumerable: true, get: function () { return codegen_1.str; } });
 	Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function () { return codegen_1.stringify; } });
@@ -20494,7 +20515,7 @@ var limit = {};
 	Object.defineProperty(exports$1, "__esModule", { value: true });
 	exports$1.formatLimitDefinition = void 0;
 	const ajv_1 = ajvExports;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const ops = codegen_1.operators;
 	const KWDs = {
 	    formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
@@ -20565,7 +20586,7 @@ var limit = {};
 	Object.defineProperty(exports$1, "__esModule", { value: true });
 	const formats_1 = formats;
 	const limit_1 = limit;
-	const codegen_1 = codegen;
+	const codegen_1 = requireCodegen();
 	const fullName = new codegen_1.Name("fullFormats");
 	const fastName = new codegen_1.Name("fastFormats");
 	const formatsPlugin = (ajv, opts = { keywords: true }) => {
@@ -23037,8 +23058,8 @@ function getAutomationFramework(workingDirectory, activeFile) {
 }
 
 var name = "@applitools/mcp";
-var mcpName = "io.github.Applitools/applitools";
-var version = "0.4.0";
+var mcpName = "io.github.applitools/applitools";
+var version = "0.4.2";
 var description = "Applitools MCP server for AI coding assistants";
 var main = "./dist/index.js";
 var bin = "./dist/index.js";
@@ -23287,7 +23308,7 @@ class ApiClient {
             throw new MissingApiKeyError();
         }
         try {
-            const response = await req(`${this.baseUrl}/${endpoint}`, {
+            const response = await req.req(`${this.baseUrl}/${endpoint}`, {
                 method: 'GET',
                 headers: {
                     'X-Eyes-Api-Key': this.apiKey,
@@ -23389,7 +23410,7 @@ class ApiClient {
             };
             // Add API key to query for POST requests (Eyes API pattern)
             const url = `${this.baseUrl}/${endpoint}${endpoint.includes('?') ? '&' : '?'}apiKey=${this.apiKey}`;
-            const response = await req(url, reqOptions);
+            const response = await req.req(url, reqOptions);
             // Handle authentication errors
             if (response.status === 401) {
                 throw new InvalidApiKeyError(this.apiKey);