vega2ol 1.1.4 → 1.1.6

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * vega2ol - Vega expression to OpenLayers expression transpiler
+ */
+export { vega2ol, Vega2OLError, VegaNode } from './main.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+/**
+ * vega2ol - Vega expression to OpenLayers expression transpiler
+ */
+export { vega2ol, Vega2OLError } from './main.js';

package/dist/main.d.ts

@@ -0,0 +1,37 @@
+import type { ExpressionValue } from "ol/expr/expression.js";
+/**
+ * OpenLayers expression types
+ * OL expressions are arrays: ['operator', arg1, arg2, ...] or ['case', condition, value, ...]
+ */
+/**
+ * Vega AST node types (simplified)
+ */
+interface VegaNode {
+    type: string;
+    [key: string]: any;
+}
+/**
+ * Operator mapping from Vega operators to OpenLayers operators
+ */
+export declare const OPERATOR_MAPPING: Record<string, string>;
+/**
+ * Constants mapping from Vega constants to OpenLayers constants
+ */
+export declare const CONSTANTS_MAPPING: Record<string, number>;
+/**
+ * Function mapping from Vega functions to OpenLayers functions
+ */
+export declare const FUNCTION_MAPPING: Record<string, string>;
+/**
+ * Custom error class for Vega2OL transpilation errors
+ */
+export declare class Vega2OLError extends Error {
+    constructor(message: string);
+}
+/**
+ * Main transpiler function
+ * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
+ * @returns OpenLayers expression array
+ */
+export declare function vega2ol(vegaExpressionStr: string): ExpressionValue;
+export { ExpressionValue as OLExpression, VegaNode };

package/dist/main.js

@@ -0,0 +1,286 @@
+import { parseExpression } from "vega-expression";
+/**
+ * Operator mapping from Vega operators to OpenLayers operators
+ */
+export const OPERATOR_MAPPING = {
+    // Comparison operators
+    "==": "==",
+    "!=": "!=",
+    "<": "<",
+    "<=": "<=",
+    ">": ">",
+    ">=": ">=",
+    // Logical operators
+    "&&": "all",
+    "||": "any",
+    // Arithmetic operators
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "%": "%",
+};
+/**
+ * Constants mapping from Vega constants to OpenLayers constants
+ */
+export const CONSTANTS_MAPPING = {
+    PI: Math.PI,
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    SQRT1_2: Math.SQRT1_2,
+    SQRT2: Math.SQRT2,
+    MIN_VALUE: Number.MIN_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
+};
+/**
+ * Function mapping from Vega functions to OpenLayers functions
+ */
+export const FUNCTION_MAPPING = {
+    // Math functions
+    abs: "abs",
+    floor: "floor",
+    ceil: "ceil",
+    round: "round",
+    sqrt: "sqrt",
+    pow: "^",
+    sin: "sin",
+    cos: "cos",
+    atan: "atan",
+    atan2: "atan",
+    clamp: "clamp",
+    rgb: "rgb",
+};
+/**
+ * Custom error class for Vega2OL transpilation errors
+ */
+export class Vega2OLError extends Error {
+    constructor(message) {
+        const fullMessage = `${message}, note that only a subset of Vega is supported`;
+        super(fullMessage);
+        this.name = "Vega2OLError";
+    }
+}
+/**
+ * Visitor class to convert Vega AST to OpenLayers expressions
+ */
+class VegaToOLVisitor {
+    constructor() {
+        this.scope = {};
+    }
+    isNegativeOne(node) {
+        // Case 1: Literal -1
+        if (node.type === "Literal" && node.value === -1) {
+            return true;
+        }
+        // Case 2: UnaryExpression: -1
+        if (node.type === "UnaryExpression" &&
+            node.operator === "-" &&
+            node.argument?.type === "Literal" &&
+            node.argument.value === 1) {
+            return true;
+        }
+        return false;
+    }
+    visit(node) {
+        if (!node || !node.type) {
+            throw new Vega2OLError("Invalid AST node");
+        }
+        const method = `visit${node.type}`;
+        if (typeof this[method] === "function") {
+            return this[method](node);
+        }
+        throw new Vega2OLError(`Unsupported ${node.type} node`);
+    }
+    // Literal values
+    visitLiteral(node) {
+        const { value } = node;
+        if (value === null)
+            return null;
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return value;
+        throw new Vega2OLError(`Unsupported literal type: ${typeof value}`);
+    }
+    // Member access: datum.value, datum['value']
+    visitMemberExpression(node) {
+        const { object, property } = node;
+        if (object.type === "Identifier" && object.name === "datum") {
+            if (typeof property === "string") {
+                return ["get", property];
+            }
+            // For computed properties - if property is an Identifier with 'name'
+            if (property.type === "Identifier" && property.name) {
+                return ["get", property.name];
+            }
+            // For computed properties like datum[variable]
+            return ["get", this.visit(property)];
+        }
+        throw new Vega2OLError(`Unsupported member access`);
+    }
+    isIndexOfCall(node) {
+        return (node.type === "CallExpression" &&
+            node.callee?.type === "Identifier" &&
+            node.callee.name.toLowerCase() === "indexof");
+    }
+    // Binary operations: a + b, a > b, etc.
+    visitBinaryExpression(node) {
+        const { operator, left, right } = node;
+        // Special handling for indexOf comparisons
+        if (operator === "!=" || operator === "==") {
+            let call = null;
+            if (this.isIndexOfCall(left) && this.isNegativeOne(right)) {
+                call = left;
+            }
+            else if (this.isIndexOfCall(right) && this.isNegativeOne(left)) {
+                call = right;
+            }
+            if (call) {
+                const [arrayArg, valueArg] = call.arguments || [];
+                if (arrayArg && valueArg) {
+                    const arrayOL = this.visit(arrayArg);
+                    const valueOL = this.visit(valueArg);
+                    const inExpr = [
+                        "in",
+                        valueOL,
+                        ["literal", arrayOL],
+                    ];
+                    // indexof(...) != -1 → is in
+                    if (operator === "!=") {
+                        return inExpr;
+                    }
+                    // indexof(...) == -1 → is NOT in
+                    if (operator === "==") {
+                        return ["!", inExpr];
+                    }
+                }
+            }
+        }
+        const leftOL = this.visit(left);
+        const rightOL = this.visit(right);
+        const olOp = OPERATOR_MAPPING[operator];
+        if (!olOp) {
+            throw new Vega2OLError(`Unsupported binary operator: ${operator}`);
+        }
+        return [olOp, leftOL, rightOL];
+    }
+    // Unary operations: !x, -x, +x
+    visitUnaryExpression(node) {
+        const { operator, argument } = node;
+        const argOL = this.visit(argument);
+        if (operator === "!") {
+            return ["!", argOL];
+        }
+        if (operator === "-") {
+            return ["*", argOL, -1];
+        }
+        if (operator === "+") {
+            return argOL;
+        }
+        throw new Vega2OLError(`Unsupported unary operator: ${operator}`);
+    }
+    // Conditional: test ? consequent : alternate
+    visitConditionalExpression(node) {
+        const { test, consequent, alternate } = node;
+        const testOL = this.visit(test);
+        const consequentOL = this.visit(consequent);
+        const alternateOL = this.visit(alternate);
+        // OL 'case' expression: ['case', condition1, value1, condition2, value2, ..., defaultValue]
+        return ["case", testOL, consequentOL, alternateOL];
+    }
+    // Function calls: floor(x), ceil(y), etc.
+    visitCallExpression(node) {
+        const { callee, arguments: args } = node;
+        let funcName;
+        if (callee.type === "Identifier") {
+            funcName = callee.name;
+        }
+        else if (callee.type === "MemberExpression" &&
+            callee.object.name === "Math") {
+            funcName = callee.property;
+        }
+        else {
+            throw new Vega2OLError(`Unsupported function call`);
+        }
+        if (this.isIndexOfCall(node)) {
+            throw new Vega2OLError(`indexof is only supported in the pattern 'indexof(array, value) != -1' (or '== -1'), ` +
+                `it cannot be used as a standalone expression in OpenLayers`);
+        }
+        // rgb(r, g, b[, opacity]) → OL ['color', r, g, b, a].
+        if (funcName.toLowerCase() === "rgb" &&
+            (args.length === 3 || args.length === 4)) {
+            const [r, g, b, a] = args;
+            return [
+                "color",
+                this.visit(r),
+                this.visit(g),
+                this.visit(b),
+                a ? this.visit(a) : 1,
+            ];
+        }
+        const olFunc = FUNCTION_MAPPING[funcName.toLowerCase()];
+        if (!olFunc) {
+            throw new Vega2OLError(`Unsupported function: ${funcName}`);
+        }
+        const olArgs = args.map((arg) => this.visit(arg));
+        return [olFunc, ...olArgs];
+    }
+    // Array literal: [1, 2, 3]
+    visitArrayExpression(node) {
+        const { elements } = node;
+        return elements.map((elem) => this.visit(elem));
+    }
+    // Logical expressions
+    visitLogicalExpression(node) {
+        const { operator, left, right } = node;
+        const leftOL = this.visit(left);
+        const rightOL = this.visit(right);
+        const olOp = OPERATOR_MAPPING[operator];
+        if (!olOp) {
+            throw new Vega2OLError(`Unsupported logical operator: ${operator}`);
+        }
+        return [olOp, leftOL, rightOL];
+    }
+    // Identifier/Variable: x, PI, etc.
+    visitIdentifier(node) {
+        const { name } = node;
+        // Check if it's in the current scope
+        if (name in this.scope) {
+            return this.scope[name];
+        }
+        if (name in CONSTANTS_MAPPING) {
+            return CONSTANTS_MAPPING[name];
+        }
+        // Return as string (might be a function or field)
+        return name;
+    }
+}
+/**
+ * Main transpiler function
+ * @param vegaExpressionStr - A Vega expression string (e.g., "datum.value > 100 ? 'red' : 'blue'")
+ * @returns OpenLayers expression array
+ */
+export function vega2ol(vegaExpressionStr) {
+    if (typeof vegaExpressionStr !== "string") {
+        throw new Vega2OLError("Input must be a string");
+    }
+    try {
+        // Parse Vega expression to AST
+        const ast = parseExpression(vegaExpressionStr);
+        // Visit the AST and convert to OL expression
+        const visitor = new VegaToOLVisitor();
+        const olExpression = visitor.visit(ast);
+        return olExpression;
+    }
+    catch (error) {
+        if (error instanceof Vega2OLError) {
+            throw error;
+        }
+        throw new Vega2OLError(`Failed to parse expression: ${error.message}`);
+    }
+}

package/dist/tests/test-basic.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/test-basic.js

@@ -0,0 +1,319 @@
+import { vega2ol, Vega2OLError } from "../main.js";
+// Simple assertion helper
+function assertEqual(actual, expected, message) {
+    const actualStr = JSON.stringify(actual);
+    const expectedStr = JSON.stringify(expected);
+    if (actualStr === expectedStr) {
+        console.log(`   ✅ ${message}`);
+        return true;
+    }
+    else {
+        console.log(`   ❌ ${message}`);
+        console.log(`   Expected: ${expectedStr}`);
+        console.log(`   Got:      ${actualStr}`);
+        return false;
+    }
+}
+// Assert that vega2ol throws a Vega2OLError for the given expression
+async function assertThrows(expr, message, messageContains) {
+    try {
+        const result = await vega2ol(expr);
+        console.log(`   ❌ ${message}`);
+        console.log(`   Expected a Vega2OLError, but got result: ${JSON.stringify(result)}`);
+        return false;
+    }
+    catch (error) {
+        if (!(error instanceof Vega2OLError)) {
+            console.log(`   ❌ ${message}`);
+            console.log(`   Expected Vega2OLError, got: ${error.constructor.name}: ${error.message}`);
+            return false;
+        }
+        if (messageContains && !error.message.includes(messageContains)) {
+            console.log(`   ❌ ${message}`);
+            console.log(`   Error message did not contain "${messageContains}"`);
+            console.log(`   Got message: ${error.message}`);
+            return false;
+        }
+        console.log(`   ✅ ${message}`);
+        return true;
+    }
+}
+// Run tests
+async function runTests() {
+    console.log("🚀 Testing vega2ol transpiler\n");
+    let passed = 0;
+    let failed = 0;
+    try {
+        // Test 1: Literal values
+        console.log("📋 Literal Values");
+        if (assertEqual(await vega2ol("42"), 42, "Number literal"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("'hello'"), "hello", "String literal"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("true"), true, "Boolean literal"))
+            passed++;
+        else
+            failed++;
+        // Test 2: Member access
+        console.log("\n📋 Member Access (datum.field)");
+        if (assertEqual(await vega2ol("datum.value"), ["get", "value"], "Simple datum access"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("datum.population"), ["get", "population"], "Datum field access"))
+            passed++;
+        else
+            failed++;
+        // Test 3: Comparison operators
+        console.log("\n📋 Comparison Operators");
+        if (assertEqual(await vega2ol("datum.value > 100"), [">", ["get", "value"], 100], "Greater than operator"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("datum.value == 100"), ["==", ["get", "value"], 100], "Equality operator"))
+            passed++;
+        else
+            failed++;
+        // Test 4: Ternary/Conditional (the main example from docs)
+        console.log("\n📋 Conditional Expressions");
+        if (assertEqual(await vega2ol("datum.value > 100 ? 'red' : 'blue'"), ["case", [">", ["get", "value"], 100], "red", "blue"], "Simple ternary expression"))
+            passed++;
+        else
+            failed++;
+        // Test 5: Complex nested conditional
+        if (assertEqual(await vega2ol("datum.value > 100 ? 'red' : datum.value > 50 ? 'yellow' : 'green'"), [
+            "case",
+            [">", ["get", "value"], 100],
+            "red",
+            ["case", [">", ["get", "value"], 50], "yellow", "green"],
+        ], "Nested ternary expression"))
+            passed++;
+        else
+            failed++;
+        // Test 6: Logical operators
+        console.log("\n📋 Logical Operators");
+        if (assertEqual(await vega2ol("datum.x > 0 && datum.y < 100"), ["all", [">", ["get", "x"], 0], ["<", ["get", "y"], 100]], "AND operator"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("datum.a > 1 || datum.b < 5"), ["any", [">", ["get", "a"], 1], ["<", ["get", "b"], 5]], "OR operator"))
+            passed++;
+        else
+            failed++;
+        // Test 7: Arithmetic operators
+        console.log("\n📋 Arithmetic Operators");
+        if (assertEqual(await vega2ol("datum.a + datum.b"), ["+", ["get", "a"], ["get", "b"]], "Addition operator"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("datum.a * datum.b"), ["*", ["get", "a"], ["get", "b"]], "Multiplication operator"))
+            passed++;
+        else
+            failed++;
+        // Test 8: Unary operations
+        console.log("\n📋 Unary Operations");
+        if (assertEqual(await vega2ol("!datum.active"), ["!", ["get", "active"]], "Negation operator"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-datum.value"), ["*", ["get", "value"], -1], "Unary minus"))
+            passed++;
+        else
+            failed++;
+        // Test 9: Function calls
+        console.log("\n📋 Function Calls");
+        if (assertEqual(await vega2ol("floor(datum.value)"), ["floor", ["get", "value"]], "Floor function"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("ceil(datum.value)"), ["ceil", ["get", "value"]], "ceil()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("round(datum.value)"), ["round", ["get", "value"]], "round()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("abs(datum.value)"), ["abs", ["get", "value"]], "abs()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("sqrt(datum.value)"), ["sqrt", ["get", "value"]], "sqrt()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("sin(datum.value)"), ["sin", ["get", "value"]], "sin()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("cos(datum.value)"), ["cos", ["get", "value"]], "cos()"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("pow(datum.base, 2)"), ["^", ["get", "base"], 2], "pow() maps to OL's '^' operator, not a 'pow' function"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("atan(datum.value)"), ["atan", ["get", "value"]], "atan() single-arg form"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("atan2(datum.x, datum.y)"), ["atan", ["get", "x"], ["get", "y"]], "atan2() two-arg form"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("clamp(datum.value, 0, 100)"), ["clamp", ["get", "value"], 0, 100], "clamp() preserves (value, min, max) arg order"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("rgb(255, 0, 0)"), ["color", 255, 0, 0, 1], "rgb() with 3 numeric literals, default opacity"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("rgb(255, 0, 0, 0.5)"), ["color", 255, 0, 0, 0.5], "rgb() with explicit opacity"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("rgb(datum.r, datum.g, datum.b)"), ["color", ["get", "r"], ["get", "g"], ["get", "b"], 1], "rgb() with dynamic field args, default opacity"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("rgb(sqrt(50), 0, 0, 0.5)"), ["color", ["sqrt", 50], 0, 0, 0.5], "rgb() with nested function call as a channel arg"))
+            passed++;
+        else
+            failed++;
+        // Test 10: Real-world example - Color mapping
+        console.log("\n📋 Real-world Examples");
+        if (assertEqual(await vega2ol("datum.population > 1000000 ? '#FF0000' : datum.population > 500000 ? '#FFA500' : '#FFFF00'"), [
+            "case",
+            [">", ["get", "population"], 1000000],
+            "#FF0000",
+            ["case", [">", ["get", "population"], 500000], "#FFA500", "#FFFF00"],
+        ], "Color mapping by population size"))
+            passed++;
+        else
+            failed++;
+        // Test 11: Array expressions
+        console.log("\n📋 Array Expressions");
+        if (assertEqual(await vega2ol("[1, 2, 3]"), [1, 2, 3], "Array literal"))
+            passed++;
+        else
+            failed++;
+        // Test 12: Constants
+        console.log("\n📋 Vega Constants");
+        if (assertEqual(await vega2ol("PI"), Math.PI, "PI constant"))
+            passed++;
+        else
+            failed++;
+        // Test 13: Binary expressions
+        console.log("\n📋 Binary Expressions");
+        if (assertEqual(await vega2ol("indexof(['USA', 'India'], datum.country) != -1"), ["in", ["get", "country"], ["literal", ["USA", "India"]]], "indexOf with != -1 (is in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 != indexof(['USA', 'India'], datum.country)"), ["in", ["get", "country"], ["literal", ["USA", "India"]]], "reverse indexOf with != -1 (is in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("indexof(['hot', 'warm'], datum.temperature) != -1 ? 'red' : 'blue'"), [
+            "case",
+            ["in", ["get", "temperature"], ["literal", ["hot", "warm"]]],
+            "red",
+            "blue",
+        ], "indexOf in ternary (if in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("indexof(['USA', 'India'], datum.country) == -1"), ["!", ["in", ["get", "country"], ["literal", ["USA", "India"]]]], "indexOf with == -1 (is not in)"))
+            passed++;
+        else
+            failed++;
+        if (assertEqual(await vega2ol("-1 == indexof(['USA', 'India'], datum.country)"), ["!", ["in", ["get", "country"], ["literal", ["USA", "India"]]]], "reverse indexOf with == -1 (is not in)"))
+            passed++;
+        else
+            failed++;
+        // Test 14: Unsupported / unknown function errors
+        console.log("\n📋 Errors: Vega Functions With No OL Equivalent");
+        if (await assertThrows("upper(datum.name)", "upper() throws (no OL string case operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("lower(datum.name)", "lower() throws (no OL string case operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("toString(datum.value)", "toString() throws (no OL type coercion operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("isValid(datum.value)", "isValid() throws (no OL type-checking operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("length(datum.items)", "length() throws (no OL length operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("format(datum.value, ',.2f')", "format() throws (no OL number-formatting operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("now()", "now() throws (no OL date/time operators)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("min(datum.a, datum.b)", "min() throws (no OL aggregate min/max operator)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("tan(datum.value)", "tan() throws (OL only supports sin/cos/atan)", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("indexof(datum.items, 'x')", "bare indexof() outside the != -1 / == -1 pattern throws a specific error", "indexof is only supported in the pattern"))
+            passed++;
+        else
+            failed++;
+        console.log("\n📋 Errors: Names That Don't Exist In Vega Or OL");
+        if (await assertThrows("totallyMadeUpFunction(datum.value)", "Nonexistent function name throws", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        if (await assertThrows("fooBarBaz(1, 2, 3)", "Another nonexistent function name throws", "Unsupported function"))
+            passed++;
+        else
+            failed++;
+        // Test 15: Error handling
+        console.log("\n📋 Error Handling");
+        try {
+            await vega2ol(null);
+            console.log("❌ Should throw for null input");
+            failed++;
+        }
+        catch (error) {
+            if (error instanceof Vega2OLError) {
+                console.log("   ✅ Throws Vega2OLError for invalid input");
+                passed++;
+            }
+            else {
+                console.log("❌ Wrong error type");
+                failed++;
+            }
+        }
+    }
+    catch (error) {
+        console.error("🔥 Test suite error:", error);
+        failed++;
+    }
+    // Summary
+    console.log("\n" + "=".repeat(50));
+    console.log(`📊 Test Results: ${passed} passed, ${failed} failed`);
+    console.log("=".repeat(50));
+    return failed === 0 ? 0 : 1;
+}
+// Run the tests
+runTests().then((code) => process.exit(code));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vega2ol",
-    "version": "1.1.4",
+    "version": "1.1.6",
     "description": "Vega expression to Open-Layers expression transpiler",
     "keywords": [
         "vega",