@emuanalytics/flow-rdf-core 4.0.4 → 4.0.6

package/dist/shared/flow-rdf-core.06e85a6c.cjs

@@ -1,1394 +0,0 @@
-'use strict';
-
-const mobx = require('mobx');
-const randomId = require('./flow-rdf-core.f50908f0.cjs');
-const maplibreSpec = require('@emuanalytics/maplibre-gl-style-spec');
-const mobxUtils = require('mobx-utils');
-const P = require('parsimmon');
-const colorbrewer = require('colorbrewer');
-const Debug = require('debug');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const mobx__namespace = /*#__PURE__*/_interopNamespaceCompat(mobx);
-const maplibreSpec__namespace = /*#__PURE__*/_interopNamespaceCompat(maplibreSpec);
-const P__default = /*#__PURE__*/_interopDefaultCompat(P);
-const colorbrewer__default = /*#__PURE__*/_interopDefaultCompat(colorbrewer);
-const Debug__default = /*#__PURE__*/_interopDefaultCompat(Debug);
-
-class FlowError extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = this.constructor.name;
-    this.cause = cause;
-  }
-}
-
-class FlowExpressionError extends FlowError {
-  constructor(expression, reason, errors) {
-    super(`Failed to evaluate expression:
-${expression}
-------
-${errors.join(", ")}`);
-    this.reason = reason;
-    this.errors = errors;
-  }
-}
-
-function PREFIX(operatorsParser, nextParser) {
-  const parser = P__default.lazy(() => {
-    return P__default.seq(operatorsParser, parser).or(nextParser);
-  });
-  return parser;
-}
-function BINARY_RIGHT(operatorsParser, nextParser) {
-  const parser = P__default.lazy(() => nextParser.chain((next) => P__default.seq(operatorsParser, P__default.of(next), parser).or(P__default.of(next))));
-  return parser;
-}
-function TERNARY_RIGHT(operatorsParser, nextParser) {
-  const parser = P__default.lazy(
-    () => nextParser.chain(
-      (next) => P__default.seqMap(
-        operatorsParser,
-        P__default.of(next),
-        parser,
-        P__default.string(":").trim(P__default.optWhitespace),
-        parser,
-        (op, cond, val1, _colon, val2) => [op, ["to-boolean", cond], val1, val2]
-      ).or(P__default.of(next))
-    )
-  );
-  return parser;
-}
-function BINARY_LEFT(operatorsParser, nextParser) {
-  return P__default.seqMap(nextParser, P__default.seq(operatorsParser, nextParser).many(), (first, rest) => {
-    return rest.reduce((acc, ch) => {
-      const [op, another] = ch;
-      return [op, acc, another];
-    }, first);
-  });
-}
-
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => {
-  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class ExpressionParser {
-  constructor() {
-    __publicField$7(this, "language");
-    this.language = this.createLanguage();
-  }
-  /**
-   * Parse an expression
-   *
-   * @param expr Expression to parse
-   */
-  parseExpression(expr) {
-    return this.language.Expr.parse(expr);
-  }
-  /**
-   * Parse a complete assignment program of the form:
-   * a: expr1;
-   * b: expr2;
-   *
-   * @param program Program to parse
-   */
-  parseProgram(program) {
-    return this.language.ProgramOrEmpty.parse(program);
-  }
-  createLanguage() {
-    const operatorTable = [
-      { type: PREFIX, ops: this.operators({ "-": "-", "!": "!" }) },
-      { type: BINARY_RIGHT, ops: this.operators({ "^": "**" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "*": "*", "/": "/", "%": "%" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "+": "+", "-": "-" }) },
-      { type: BINARY_LEFT, ops: this.operators({ ">=": ">=", "<=": "<=" }) },
-      { type: BINARY_LEFT, ops: this.operators({ "<": "<", ">": ">" }) },
-      {
-        type: BINARY_LEFT,
-        ops: this.operators({ regexi: "~*", equali: "=*", "==": "==", "!=": "!=", "~": "~" })
-      },
-      { type: BINARY_LEFT, ops: this.operators({ all: "&&" }) },
-      { type: BINARY_LEFT, ops: this.operators({ any: "||" }) },
-      { type: TERNARY_RIGHT, ops: this.operators({ case: "?" }) }
-    ];
-    return P__default.createLanguage({
-      Whitespace: () => P__default.regexp(/[ \n]*/).desc("whitespace"),
-      NotNewline: () => P__default.regexp(/[^\n]*/).desc("non-newline"),
-      LineComment: (r) => r.NotNewline.wrap(P__default.string("//"), P__default.alt(P__default.string("\n"), P__default.eof)),
-      BlockComment: () => P__default.regexp(/\/\*[\s\S]*?\*\//),
-      Comment: (r) => P__default.alt(r.LineComment, r.BlockComment).desc("comment"),
-      End: () => P__default.alt(P__default.string(";"), P__default.eof),
-      _: (r) => r.Comment.sepBy(r.Whitespace).trim(r.Whitespace),
-      Integer: () => {
-        return P__default.regexp(/-?[0-9]+/).map(Number);
-      },
-      Decimal: () => {
-        return P__default.regexp(/-?[0-9]+\.[0-9]+/).map(Number);
-      },
-      Number: (r) => {
-        return P__default.alt(r.Decimal, r.Integer).desc("number");
-      },
-      Boolean: () => {
-        return P__default.alt(P__default.string("true"), P__default.string("false")).map((val) => val === "true").desc("boolean");
-      },
-      Null: () => {
-        return P__default.string("null").result(null).desc("null");
-      },
-      DoubleQuoteString: () => {
-        return P__default.regexp(/"((?:\\.|.)*?)"/, 1).desc("string");
-      },
-      SingleQuoteString: () => {
-        return P__default.regexp(/'((?:\\.|.)*?)'/, 1).desc("string");
-      },
-      UnquotedString: () => {
-        return P__default.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/).desc("string");
-      },
-      HexColor: () => {
-        return P__default.regexp(/#(?:[0-9a-f]{3}){1,2}/i).desc("hex color");
-      },
-      String: (r) => {
-        return P__default.alt(r.SingleQuoteString, r.DoubleQuoteString, r.HexColor, r.UnquotedString).map(
-          (s) => s.replace(/\\n/gm, "\n")
-        );
-      },
-      Symbol: () => {
-        return P__default.regexp(/[a-zA-Z_][a-zA-Z0-9_-]*/).desc("symbol");
-      },
-      PartialSymbol: () => {
-        return P__default.regexp(/[a-zA-Z0-9_-]+/).desc("symbol");
-      },
-      Feature: (r) => {
-        return P__default.seqMap(
-          P__default.string("@"),
-          r.PartialSymbol.sepBy(P__default.string(".")),
-          (_feat, symbols) => ["get"].concat(symbols)
-        );
-      },
-      FeatureState: (r) => {
-        return P__default.seqMap(
-          P__default.string("@@"),
-          r.PartialSymbol.sepBy(P__default.string(".")),
-          (_feat, symbols) => this.expandFeatureState(symbols)
-        );
-      },
-      Array: (r) => P__default.string("[").trim(r._).then(r.Value.trim(r._).sepBy(P__default.string(","))).skip(P__default.string("]")),
-      State: (r) => {
-        return P__default.seqMap(
-          P__default.string("$"),
-          r.PartialSymbol.sepBy(P__default.string(".")),
-          (_state, symbols) => ["state"].concat(symbols)
-        );
-      },
-      Paren: (r) => {
-        return P__default.seqMap(P__default.string("("), r.Expr.trim(r._), P__default.string(")"), (_lb, expr, _rb) => expr);
-      },
-      Func: (r) => {
-        return P__default.seqMap(
-          r.Symbol.trim(r._),
-          P__default.string("("),
-          r.Expr.trim(r._).sepBy(P__default.string(",")),
-          P__default.string(")"),
-          (func, _lb, args, _rb) => [func, ...args]
-        );
-      },
-      Value: (r) => {
-        return P__default.alt(
-          r.Paren,
-          r.Array,
-          r.Func,
-          r.Boolean,
-          r.Null,
-          r.Number,
-          r.String,
-          r.FeatureState,
-          r.Feature,
-          r.State
-        );
-      },
-      Expr: (r) => {
-        return this.tableParser(operatorTable, r.Value);
-      },
-      PropertyName: () => {
-        return P__default.regexp(/[a-zA-Z_-][a-zA-Z0-9_-]*/).desc("symbol");
-      },
-      Assignment: (r) => {
-        return P__default.seqMap(
-          r.PropertyName,
-          P__default.string(":").trim(r._),
-          r.Expr.trim(r._).node("expr"),
-          r.End,
-          (key, _colon, node) => [key, { expr: node.value, start: node.start, end: node.end }]
-        );
-      },
-      Program: (r) => {
-        return r.Assignment.trim(r._).many().map((statements) => {
-          return statements.filter((s) => s !== "").reduce((acc, s) => {
-            acc[s[0]] = s[1];
-            return acc;
-          }, {});
-        });
-      },
-      EmptyProgram: (r) => {
-        return P__default.seqMap(r._, P__default.eof, () => null);
-      },
-      ProgramOrEmpty: (r) => {
-        return P__default.alt(r.EmptyProgram, r.Program);
-      }
-    });
-  }
-  /**
-   * Helper function to create a parser that parsers a set of operators at the same precedence level
-   *
-   * @param ops Operator table
-   */
-  operators(ops) {
-    const keys = Object.keys(ops);
-    const ps = keys.map((k) => P__default.string(ops[k]).trim(P__default.optWhitespace).result(k));
-    return P__default.alt.apply(null, ps);
-  }
-  /**
-   * Helper function to create a table-driver operator parser
-   *
-   */
-  tableParser(operatorTable, valueParser) {
-    return operatorTable.reduce((acc, level) => level.type(level.ops, acc), valueParser);
-  }
-  expandFeatureState(symbols) {
-    let expandedFeatureState = ["feature-state", symbols.shift()];
-    symbols.forEach((s) => expandedFeatureState = ["get", s, expandedFeatureState]);
-    return expandedFeatureState;
-  }
-}
-
-const palettes = {};
-function registerColorBrewerPalettes() {
-  Object.keys(colorbrewer__default).filter((key) => key !== "schemeGroups").forEach(
-    (key) => palettes[key.toLowerCase()] = {
-      id: key,
-      colors: colorbrewer__default[key][5]
-    }
-  );
-}
-function fromPalette(expr, parentExpression) {
-  const paletteIdOrArray = expr[1];
-  const property = expr[2];
-  let colorStops = expr.slice(3);
-  let palette;
-  if (randomId.isString(paletteIdOrArray)) {
-    palette = palettes[paletteIdOrArray.toLowerCase()]?.colors || palettes["Greys"].colors;
-  } else if (randomId.isArray(paletteIdOrArray) && paletteIdOrArray[0] === "literal") {
-    palette = paletteIdOrArray[1];
-  } else {
-    throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-      "from-palette requires palette id as string or custom palette array"
-    ]);
-  }
-  const numPaletteEntries = palette.length;
-  let reversePalette = false;
-  if (numPaletteEntries < 5) {
-    throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-      "custom palette requires at least 5 color entries"
-    ]);
-  }
-  switch (colorStops.length) {
-    case 2:
-      break;
-    case 3:
-      reversePalette = !!colorStops[2];
-      colorStops = colorStops.slice(0, 2);
-      break;
-    case numPaletteEntries:
-      break;
-    case numPaletteEntries + 1:
-      reversePalette = !!colorStops[numPaletteEntries];
-      colorStops = colorStops.slice(0, numPaletteEntries);
-      break;
-    default:
-      throw new FlowExpressionError(parentExpression.expression, "evaluationError", [
-        "incorrect color stop arguments"
-      ]);
-  }
-  if (colorStops.length === 2) {
-    const min = colorStops[0];
-    const max = colorStops[1];
-    colorStops = [];
-    const step = (max - min) / (numPaletteEntries - 1);
-    for (let i = 0; i < numPaletteEntries; i++) {
-      colorStops.push(min + i * step);
-    }
-  }
-  expr = ["interpolate-lab", ["linear"], property];
-  for (let i = 0; i < colorStops.length; i++) {
-    expr.push(colorStops[i]);
-    expr.push(reversePalette ? palette[colorStops.length - i - 1] : palette[i]);
-  }
-  return expr;
-}
-const customFromPaletteFn = {
-  name: "from-palette",
-  initialize: registerColorBrewerPalettes,
-  fn: fromPalette
-};
-
-function regexFunction(operator, caseSensitive = true) {
-  return (expr, _) => {
-    expr[0] = operator;
-    expr.push(["collator", { "case-sensitive": caseSensitive }]);
-    return expr;
-  };
-}
-const equal = {
-  name: "equal",
-  fn: regexFunction("==", true)
-};
-const equali = {
-  name: "iequal",
-  fn: regexFunction("==", false)
-};
-const regex = {
-  name: "regex",
-  fn: regexFunction("~", true)
-};
-const regexi = {
-  name: "regexi",
-  fn: regexFunction("~", false)
-};
-
-function stateCustomFunction(expr, parentExpression) {
-  if (!parentExpression.store) {
-    console.warn(
-      `The reactive expression '${parentExpression.expression}' references state properties but is not bound to a state store. The expression cannot be evaluated - returning null.`
-    );
-    return null;
-  }
-  const path = expr.slice(1).join(".");
-  const val = parentExpression.store.get(path);
-  if (randomId.isNil(val)) {
-    return null;
-  } else if (typeof val === "object") {
-    return ["literal", val];
-  } else {
-    return val;
-  }
-}
-const customStateFn = {
-  name: "state",
-  fn: stateCustomFunction
-};
-
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => {
-  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _ReactiveExpression = class _ReactiveExpression {
-  constructor(expression, parsedExpression) {
-    __publicField$6(this, "_expression", "");
-    __publicField$6(this, "parsedResult");
-    __publicField$6(this, "_store", null);
-    mobx.makeObservable(
-      this,
-      {
-        _store: mobx.observable.ref,
-        maplibreExpression: mobx.computed,
-        value: mobx.computed,
-        bindState: mobx.action
-      },
-      { name: this.formatName(expression) }
-    );
-    this._expression = expression;
-    if (randomId.isDefined(parsedExpression)) {
-      this.parsedResult = {
-        status: true,
-        value: parsedExpression
-      };
-    } else {
-      this.parsedResult = _ReactiveExpression.parser.parseExpression(expression);
-    }
-  }
-  static hasCustomFunction(fn) {
-    return !!this.customFunctions[fn];
-  }
-  static registerCustomFunction(fn) {
-    if (fn.initialize)
-      fn.initialize();
-    this.customFunctions[fn.name] = fn;
-  }
-  static parseProgram(program) {
-    const parsedProgram = this.parser.parseProgram(program);
-    if (randomId.isString(program) && program.length === 0) {
-      return {};
-    }
-    if (parsedProgram.status) {
-      const keys = Object.keys(parsedProgram.value);
-      const expressions = keys.reduce((accum, key) => {
-        const expr = parsedProgram.value[key];
-        const expressionString = program.slice(expr.start.offset, expr.end.offset);
-        accum[key] = new _ReactiveExpression(expressionString, expr.expr);
-        return accum;
-      }, {});
-      return expressions;
-    } else {
-      throw new FlowExpressionError(program, "parseError", [
-        `expected ${parsedProgram.expected.join(" ")} at line ${parsedProgram.index.line}, column ${parsedProgram.index.column}]`
-      ]);
-    }
-  }
-  // Computed
-  get maplibreExpression() {
-    if (this.isParseError(this.parsedResult)) {
-      throw this.parseError;
-    }
-    return this.expandCustomFunctions(this.parsedResult.value);
-  }
-  // Computed
-  get value() {
-    return this.evaluateExpression();
-  }
-  get parseError() {
-    if (this.isParseError(this.parsedResult)) {
-      return new FlowExpressionError(this._expression, "parseError", [
-        `index: ${this.parsedResult.index.offset}`,
-        `expected: ${this.parsedResult.expected.join(" ")}`
-      ]);
-    }
-    return null;
-  }
-  get expression() {
-    return this._expression;
-  }
-  get store() {
-    return this._store;
-  }
-  bindState(store) {
-    this._store = store;
-    return this;
-  }
-  toStream(fireImmediately = true) {
-    return mobxUtils.toStream(() => this.value, fireImmediately);
-  }
-  evaluateExpression() {
-    const { result, value } = maplibreSpec__namespace.expression.createExpression(this.maplibreExpression);
-    if (result === "success") {
-      return value.evaluate({ zoom: 0 });
-    }
-    throw new FlowExpressionError(
-      this.expression,
-      "evaluationError",
-      value.map((value2) => value2.message)
-    );
-  }
-  expandCustomFunctions(expr) {
-    if (this.isFunctionExpression(expr)) {
-      const func = expr[0];
-      const args = expr.slice(1).map((arg) => this.expandCustomFunctions(arg));
-      expr = [func, ...args];
-      return _ReactiveExpression.hasCustomFunction(func) ? _ReactiveExpression.customFunctions[func].fn(expr, this) : expr;
-    }
-    return expr;
-  }
-  isParseError(val) {
-    return !val.status;
-  }
-  isFunctionExpression(expr) {
-    return Array.isArray(expr);
-  }
-  formatName(expr) {
-    return `FlowCoreExpression<${expr}>}`;
-  }
-};
-__publicField$6(_ReactiveExpression, "parser", new ExpressionParser());
-__publicField$6(_ReactiveExpression, "customFunctions", {});
-let ReactiveExpression = _ReactiveExpression;
-ReactiveExpression.registerCustomFunction(customStateFn);
-ReactiveExpression.registerCustomFunction(customFromPaletteFn);
-ReactiveExpression.registerCustomFunction(regex);
-ReactiveExpression.registerCustomFunction(regexi);
-ReactiveExpression.registerCustomFunction(equal);
-ReactiveExpression.registerCustomFunction(equali);
-
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => {
-  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _MapDataSource = class _MapDataSource {
-  constructor(options) {
-    __publicField$5(this, "_options");
-    __publicField$5(this, "_srcExpression", null);
-    __publicField$5(this, "_parameters", {});
-    __publicField$5(this, "_state", null);
-    this._options = {
-      ..._MapDataSource.defaultOptions,
-      ...options
-    };
-    if (!randomId.isIn(options.type, ["vector", "geojson", "raster"])) {
-      throw new FlowError(`${this.formattedName()}: unrecognized type '${options.type}'`);
-    }
-    this.setSrcExpression(options.src);
-    mobx__namespace.makeObservable(
-      this,
-      {
-        //observable
-        _options: mobx__namespace.observable.shallow,
-        _srcExpression: mobx__namespace.observable,
-        _parameters: mobx__namespace.observable,
-        //computed
-        dataSourceSpecification: mobx__namespace.computed,
-        // actions
-        bindState: mobx__namespace.action,
-        setSrc: mobx__namespace.action,
-        setParameter: mobx__namespace.action
-      },
-      { name: this.formattedName(options.id) }
-    );
-  }
-  get id() {
-    return this._options.id;
-  }
-  get type() {
-    return this._options.type;
-  }
-  get featureId() {
-    return this._options.featureId;
-  }
-  get dataSourceSpecification() {
-    let src = this._srcExpression ? mobx__namespace.toJS(this._srcExpression.value) : this._options.src;
-    if (randomId.isString(src)) {
-      src = this.expandSrc(src, this._options.type);
-    }
-    let ds;
-    switch (this._options.type) {
-      case "vector":
-        ds = randomId.isStringFull(src) ? {
-          type: "vector",
-          url: src
-        } : (
-          // For null src use an empty geojson datasource as a placeholder
-          {
-            type: "geojson",
-            data: { type: "FeatureCollection", features: [] }
-          }
-        );
-        if (this._options.featureId) {
-          ds.promoteId = this._options.featureId;
-        }
-        return ds;
-      case "raster":
-        ds = randomId.isStringFull(src) ? {
-          type: "raster",
-          url: src
-        } : (
-          // For null src use an empty geojson datasource as a placeholder
-          {
-            type: "geojson",
-            data: { type: "FeatureCollection", features: [] }
-          }
-        );
-        return ds;
-      case "geojson":
-        ds = {
-          type: "geojson",
-          data: src || { type: "FeatureCollection", features: [] }
-        };
-        if (this._options.cluster) {
-          ds.cluster = true;
-          ds.clusterMaxZoom = this._options.clusterMaxZoom;
-          ds.clusterMinPoints = this._options.clusterMinPoints;
-          ds.clusterRadius = this._options.clusterRadius;
-        }
-        if (this._options.featureId) {
-          ds.promoteId = this._options.featureId;
-        }
-        return ds;
-      default:
-        throw new FlowError(`${this.formattedName()}: unrecognized type '${this._options.type}'`);
-    }
-  }
-  bindState(state) {
-    this._state = state;
-    if (this._srcExpression) {
-      this._srcExpression?.bindState(state);
-    }
-    Object.values(this._parameters).forEach((expr) => expr.bindState(state));
-    return this;
-  }
-  setSrc(val) {
-    this._options.src = val;
-    this.setSrcExpression(val);
-  }
-  setParameter(name, expression) {
-    if (randomId.isNil(expression)) {
-      delete this._parameters[name];
-    } else {
-      const expr = new ReactiveExpression(expression);
-      this._parameters[name] = expr.bindState(this._state);
-    }
-  }
-  setFlowEndpoint(endpoint) {
-    this._options.flowHost = endpoint.host;
-    this._options.flowApiKey = endpoint.apiKey;
-  }
-  formattedName(id) {
-    return `MapDataSource<${id || this._options.id}>`;
-  }
-  setSrcExpression(src) {
-    if (randomId.isString(src)) {
-      if (randomId.isURL(src))
-        src = `'${src}'`;
-      this._srcExpression = new ReactiveExpression(src);
-      this._srcExpression.bindState(this._state);
-    } else {
-      this._srcExpression = null;
-    }
-  }
-  /**
-   * Convert a src parameter to final URL
-   *
-   * @param src Data source url/dataset/tilesource ID
-   * @param type Data source type
-   * @returns URL
-   */
-  expandSrc(src, type) {
-    const host = this._options.flowHost;
-    let isGeoJSON = false;
-    if (!randomId.isURL(src)) {
-      switch (type) {
-        case "vector":
-        case "raster":
-          src = `${host}/tiles/${src}/index.json`;
-          break;
-        case "geojson":
-          src = `${host}/api/v1/datasets/${src}/query`;
-          isGeoJSON = true;
-          break;
-        default:
-          throw new FlowError(`${this.formattedName()}: unrecognized type '${this._options.type}'`);
-      }
-    }
-    const urlObj = new URL(src);
-    const combinedParams = new URLSearchParams(urlObj.searchParams);
-    Object.entries(this._parameters).filter(([_, expr]) => !randomId.isNil(expr.value)).forEach(([key, expr]) => combinedParams.append(key, expr.value));
-    if (this._options.flowHost && src.startsWith(this._options.flowHost) && !combinedParams.has("apikey") && this._options.flowApiKey) {
-      combinedParams.append("apikey", this._options.flowApiKey);
-    }
-    if (this._options.limit) {
-      combinedParams.append("limit", this._options.limit.toString(10));
-    }
-    if (isGeoJSON) {
-      combinedParams.append("format", "geojson");
-    }
-    urlObj.search = combinedParams.toString();
-    return urlObj.toString();
-  }
-};
-__publicField$5(_MapDataSource, "defaultOptions", {
-  type: "vector",
-  cluster: false,
-  clusterRadius: 50,
-  clusterMaxZoom: 20,
-  clusterMinPoints: 2,
-  flowHost: "https://flow.emu-analytics.net"
-});
-let MapDataSource = _MapDataSource;
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _MapLayer = class _MapLayer {
-  constructor(options) {
-    __publicField$4(this, "_options");
-    __publicField$4(this, "_state", null);
-    __publicField$4(this, "_filter", null);
-    __publicField$4(this, "_paintProps", {});
-    __publicField$4(this, "_layoutProps", {});
-    this._options = {
-      ..._MapLayer._defaultOptions,
-      ...options
-    };
-    this.getPropertyMetadata("visibility", options.type);
-    mobx.makeObservable(
-      this,
-      {
-        //observable
-        _paintProps: mobx.observable,
-        _layoutProps: mobx.observable,
-        _filter: mobx.observable,
-        _options: mobx.observable,
-        //computed
-        layerSpecification: mobx.computed,
-        // actions
-        bindState: mobx.action,
-        setMinZoom: mobx.action,
-        setMaxZoom: mobx.action,
-        setInteractive: mobx.action,
-        setAbove: mobx.action,
-        setBelow: mobx.action,
-        setStyle: mobx.action,
-        setStyleProperty: mobx.action,
-        setFilter: mobx.action
-      },
-      { name: this.formattedName(options.id) }
-    );
-    if (options.filter) {
-      this.setFilter(options.filter);
-    }
-    if (options.style) {
-      this.setStyle(options.style);
-    }
-  }
-  get layerSpecification() {
-    this._options.above;
-    this._options.below;
-    const layer = {
-      id: this._options.id,
-      type: this._options.type,
-      source: this._options.source
-    };
-    if (randomId.isDefined(this._options.minZoom)) {
-      layer.minzoom = this._options.minZoom;
-    }
-    if (randomId.isDefined(this._options.maxZoom)) {
-      layer.maxzoom = this._options.maxZoom;
-    }
-    if (randomId.isDefined(this._options.sourceLayer)) {
-      layer["source-layer"] = this._options.sourceLayer;
-    }
-    if (randomId.isDefined(this._filter)) {
-      layer.filter = this._filter.maplibreExpression;
-    }
-    if (randomId.isObjectFull(this._paintProps)) {
-      layer.paint = Object.keys(this._paintProps).reduce((accum, key) => {
-        accum[key] = this._paintProps[key].maplibreExpression;
-        return accum;
-      }, {});
-    }
-    if (randomId.isObjectFull(this._layoutProps)) {
-      layer.layout = Object.keys(this._layoutProps).reduce((accum, key) => {
-        let expr = this._layoutProps[key].maplibreExpression;
-        if (key === "visibility") {
-          expr = this._layoutProps[key].value ? "visible" : "none";
-        }
-        accum[key] = expr;
-        return accum;
-      }, {});
-    }
-    return layer;
-  }
-  get id() {
-    return this._options.id;
-  }
-  get type() {
-    return this._options.type;
-  }
-  get source() {
-    return this._options.source;
-  }
-  get interactive() {
-    return !!this._options.interactive;
-  }
-  get above() {
-    return this._options.above;
-  }
-  get below() {
-    return this._options.below;
-  }
-  bindState(state) {
-    this._state = state;
-    if (this._filter) {
-      this._filter.bindState(state);
-    }
-    Object.values(this._paintProps).forEach((prop) => prop.bindState(state));
-    Object.values(this._layoutProps).forEach((prop) => prop.bindState(state));
-    return this;
-  }
-  setMinZoom(zoom) {
-    this._options.minZoom = zoom;
-    return this;
-  }
-  setMaxZoom(zoom) {
-    this._options.maxZoom = zoom;
-    return this;
-  }
-  setInteractive(interactive) {
-    this._options.interactive = interactive;
-    return this;
-  }
-  setAbove(layerId) {
-    this._options.above = layerId;
-    return this;
-  }
-  setBelow(layerId) {
-    this._options.below = layerId;
-    return this;
-  }
-  setStyle(styleProgram) {
-    const parsedProgram = ReactiveExpression.parseProgram(styleProgram);
-    const props = Object.keys(parsedProgram);
-    props.forEach((prop) => {
-      const metadata = this.getPropertyMetadata(prop, this._options.type);
-      const layerProps = metadata.type === "paint" ? this._paintProps : this._layoutProps;
-      layerProps[prop] = parsedProgram[prop].bindState(this._state);
-    });
-  }
-  /**
-   * Set an individual style property.
-   *
-   * @param property Property name.
-   * @param expression Property style expression.
-   */
-  setStyleProperty(property, expression) {
-    const metadata = this.getPropertyMetadata(property, this._options.type);
-    const props = metadata.type === "paint" ? this._paintProps : this._layoutProps;
-    if (randomId.isNil(expression)) {
-      delete props[property];
-    } else {
-      const expr = new ReactiveExpression(expression).bindState(this._state);
-      if (expr.parseError) {
-        throw expr.parseError;
-      }
-      props[property] = expr;
-    }
-  }
-  setFilter(expression) {
-    this._filter = null;
-    if (randomId.isDefined(expression)) {
-      let expr = new ReactiveExpression(expression).bindState(this._state);
-      if (expr.parseError) {
-        throw expr.parseError;
-      }
-      if (!maplibreSpec__namespace.expression.isExpressionFilter(expr.maplibreExpression)) {
-        expr = new ReactiveExpression(expr.expression, ["to-boolean", expr.maplibreExpression]);
-      }
-      this._filter = expr;
-    }
-  }
-  formattedName(id) {
-    return `MapLayer<${id || this._options.id}>`;
-  }
-  getPropertyMetadata(property, layerType) {
-    if (!_MapLayer._propertyMetadataIndex) {
-      _MapLayer.initializePropertyMetadataIndex();
-    }
-    const layerMetadata = _MapLayer._propertyMetadataIndex[layerType];
-    if (!layerMetadata) {
-      throw new FlowError(`${this.formattedName()}: unknown layer type '${layerType}'`);
-    }
-    const propertyMetadata = layerMetadata[property];
-    if (!propertyMetadata) {
-      throw new FlowError(`${this.formattedName()}: unknown layer property '${property}'`);
-    }
-    return propertyMetadata;
-  }
-  static initializePropertyMetadataIndex() {
-    const layerTypes = Object.keys(maplibreSpec__namespace.latest.layer.type.values);
-    this._propertyMetadataIndex = layerTypes.reduce((acc, layerType) => {
-      acc[layerType] = {};
-      ["layout", "paint"].forEach((propType) => {
-        Object.keys(maplibreSpec__namespace.latest[`${propType}_${layerType}`]).forEach((prop) => {
-          acc[layerType][prop] = {
-            property: prop,
-            type: propType,
-            definition: maplibreSpec__namespace.latest[`${propType}_${layerType}`][prop]
-          };
-        });
-      });
-      return acc;
-    }, {});
-  }
-};
-__publicField$4(_MapLayer, "_propertyMetadataIndex");
-__publicField$4(_MapLayer, "_defaultOptions", {
-  interactive: true,
-  minZoom: 0,
-  maxZoom: 18
-});
-let MapLayer = _MapLayer;
-
-class FlowMapError extends FlowError {
-  constructor(message, originalError) {
-    super(message, originalError);
-  }
-}
-
-function assert(condition, message) {
-  if (!condition) {
-    throw new FlowError(message ?? "Assertion failed");
-  }
-}
-function die(message) {
-  throw new FlowError(message);
-}
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class KeyboardShortcutManager {
-  constructor() {
-    __publicField$3(this, "listeners");
-    /**
-     * Handles key events of the root handler and passes them down to listeners.
-     * @param event
-     */
-    __publicField$3(this, "handleKeyboardEvent", (event) => {
-      if (this.isInputEvent(event))
-        return;
-      const key = this.keyDefinitionFromEvent(event);
-      for (const listener of this.listeners) {
-        const handler = listener.bindings[key];
-        if (handler) {
-          const propagate = handler(event);
-          if (propagate === true) {
-            continue;
-          } else {
-            event.stopPropagation();
-            return;
-          }
-        }
-      }
-    });
-    this.listeners = [];
-    document.addEventListener("keydown", this.handleKeyboardEvent);
-  }
-  /**
-   * Adds listener to keyboard events.
-   * @param bindings Object containing key/value pairs of keyCode/eventHandler function. Can add multiple comma separated `,` keyCodes for the same handler. Can optionally return `false` to stop propagation of other handlers.
-   * @param priority Can optionally set the priority of event handler, higher value means higher priority. Defaults to 0.
-   * @returns Function that can be used to unbind the listener.
-   */
-  addListener(bindings, priority) {
-    bindings = this.splitEventBindings(bindings);
-    const listener = this.addToListeners({ bindings, priority: priority ?? 0 });
-    const removeListener = () => {
-      this.removeFromListeners(listener);
-    };
-    return removeListener;
-  }
-  /**
-   * Splits multiple keyCode events and creates a new bindings map.
-   * @param bindings
-   */
-  splitEventBindings(bindings) {
-    const splitBindings = {};
-    for (const event in bindings) {
-      event.split(",").forEach((splitEvent) => {
-        splitBindings[this.normalizeKeyDefinition(splitEvent)] = bindings[event];
-      });
-    }
-    return splitBindings;
-  }
-  /**
-   * Checks is the event comes from an input type.
-   * @param event
-   */
-  isInputEvent(event) {
-    if (event.target instanceof Node) {
-      switch (event.target.nodeName) {
-        case "INPUT":
-        case "SELECT":
-        case "TEXTAREA":
-          return true;
-        default:
-          return false;
-      }
-    }
-    return false;
-  }
-  /**
-   * Adds listener into internal array of listeners and sorts in `descending` order.
-   * @param listener
-   */
-  addToListeners(listener) {
-    this.listeners.push(listener);
-    this.listeners.sort((a, b) => b.priority - a.priority);
-    return listener;
-  }
-  /**
-   * Removes listener from internal array of listeners.
-   * @param listenerToRemove
-   */
-  removeFromListeners(listenerToRemove) {
-    this.listeners = this.listeners.filter((listener) => listener !== listenerToRemove);
-  }
-  normalizeKeyDefinition(keyDef) {
-    const parts = keyDef.split("+");
-    const ev = {
-      ctrlKey: parts.includes("Ctrl"),
-      shiftKey: parts.includes("Shift"),
-      altKey: parts.includes("Alt"),
-      metaKey: parts.includes("Meta"),
-      code: parts[parts.length - 1]
-    };
-    return this.keyDefinitionFromEvent(ev);
-  }
-  keyDefinitionFromEvent(ev) {
-    let keyDef = "";
-    if (ev.ctrlKey)
-      keyDef += "Ctrl+";
-    if (ev.shiftKey)
-      keyDef += "Shift+";
-    if (ev.altKey)
-      keyDef += "Alt+";
-    if (ev.metaKey)
-      keyDef += "Meta+";
-    keyDef += ev.code;
-    return keyDef;
-  }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const debug = Debug__default("flow:map-plugin-manager");
-class PluginManager {
-  constructor(map) {
-    __publicField$2(this, "_map");
-    __publicField$2(this, "_keyboardShortcutManager", new KeyboardShortcutManager());
-    __publicField$2(this, "_plugins", /* @__PURE__ */ new Map());
-    __publicField$2(this, "_initialized", false);
-    __publicField$2(this, "_exclusivePlugins", /* @__PURE__ */ new Set());
-    this._map = map;
-    this.map.initialized.then(() => {
-      this._initialized = true;
-      for (const plugin of this._plugins.values()) {
-        if (plugin.initialize) {
-          plugin.initialize();
-        }
-      }
-    });
-  }
-  get map() {
-    return this._map;
-  }
-  usePlugin(plugin, options) {
-    if (this._plugins.has(plugin)) {
-      const oldInstance = this._plugins.get(plugin);
-      if (oldInstance.destroy) {
-        oldInstance.destroy();
-      }
-    }
-    const pluginInstance = new plugin(this, options);
-    this._plugins.set(plugin, pluginInstance);
-    debug(`FlowMap<${this.map.id}>: Using plugin '${pluginInstance.name}'`);
-    if (this._initialized && pluginInstance.initialize)
-      pluginInstance.initialize();
-    return pluginInstance;
-  }
-  getPlugin(pluginOrName) {
-    let name;
-    let pluginInstance;
-    if (randomId.isString(pluginOrName)) {
-      pluginInstance = Array.from(this._plugins.values()).find((p) => p.name === pluginOrName);
-      name = pluginOrName;
-    } else {
-      pluginInstance = this._plugins.get(pluginOrName);
-      name = pluginOrName.name;
-    }
-    if (!pluginInstance) {
-      throw new FlowError(`<${name}>: plugin not registered`);
-    }
-    return pluginInstance;
-  }
-  removePlugin(pluginOrName) {
-    let pluginConstructor;
-    let pluginInstance;
-    if (randomId.isString(pluginOrName)) {
-      const pair = Array.from(this._plugins.entries()).find(([_, p]) => p.name === pluginOrName);
-      pluginConstructor = pair && pair[0];
-      pluginInstance = pair && pair[1];
-    } else {
-      pluginConstructor = pluginOrName;
-      pluginInstance = this._plugins.get(pluginOrName);
-    }
-    if (pluginInstance && pluginInstance.destroy) {
-      pluginInstance.destroy();
-    }
-    if (pluginConstructor)
-      this._plugins.delete(pluginConstructor);
-    return this;
-  }
-  removeAllPlugins() {
-    this._plugins.forEach((plugin) => {
-      if (plugin.destroy)
-        plugin.destroy();
-    });
-    this._plugins.clear();
-    return this;
-  }
-  setExclusivePlugin(plugin) {
-    this._exclusivePlugins.add(plugin);
-    this.forwardSetExclusivePlugin();
-    return this;
-  }
-  removeExclusivePlugin(plugin) {
-    this._exclusivePlugins.delete(plugin);
-    this.forwardSetExclusivePlugin();
-    return this;
-  }
-  addKeyboardShortcuts(keyboardShortcuts, priority = 0) {
-    return this._keyboardShortcutManager.addListener(keyboardShortcuts, priority);
-  }
-  forwardEvent(eventName, ...args) {
-    const handlerName = `handle${randomId.capitalize(eventName)}`;
-    this._plugins.forEach((plugin) => {
-      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
-        return;
-      const handler = plugin[handlerName];
-      if (handler) {
-        handler.apply(plugin, args);
-      }
-    });
-  }
-  forwardStyleChangeEvent(event) {
-    this._plugins.forEach((plugin) => {
-      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
-        return;
-      if (plugin.handleBeforeStyleChanged) {
-        const result = plugin.handleBeforeStyleChanged(event);
-        if (result) {
-          event.newStyle = result;
-        }
-      }
-    });
-    return event.newStyle;
-  }
-  forwardSetExclusivePlugin() {
-    this._plugins.forEach((plugin) => {
-      if (plugin.handleSetExclusivePlugin) {
-        plugin.handleSetExclusivePlugin(Array.from(this._exclusivePlugins));
-      }
-    });
-  }
-}
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class MapEvent {
-  constructor(type, map, originalEvent) {
-    __publicField$1(this, "type");
-    __publicField$1(this, "map");
-    __publicField$1(this, "originalEvent");
-    this.type = type;
-    this.map = map;
-    this.originalEvent = originalEvent;
-  }
-  static fromMaplibreEvent(type, map, maplibreEvent) {
-    return new MapEvent(type, map, maplibreEvent.originalEvent);
-  }
-}
-class MapMouseEvent extends MapEvent {
-  constructor(type, map, point, lngLat, features, originalEvent) {
-    super(type, map, originalEvent);
-    /**
-     * The pixel coordinates of the mouse cursor, relative to the map and measured from the top left corner.
-     */
-    __publicField$1(this, "point");
-    /**
-     * The geographic location on the map of the mouse cursor.
-     */
-    __publicField$1(this, "lngLat");
-    __publicField$1(this, "features");
-    this.point = point;
-    this.lngLat = lngLat;
-    this.features = features;
-  }
-  static fromMaplibreMouseEvent(type, maplibreMouseEvent, map, features) {
-    return new MapMouseEvent(
-      type,
-      map,
-      [maplibreMouseEvent.point.x, maplibreMouseEvent.point.y],
-      [maplibreMouseEvent.lngLat.lng, maplibreMouseEvent.lngLat.lat],
-      features,
-      maplibreMouseEvent.originalEvent
-    );
-  }
-}
-class MapSourceEvent extends MapEvent {
-  constructor(type, map, source) {
-    super(type, map);
-    __publicField$1(this, "source");
-    this.source = source;
-  }
-}
-class MapLoadingEvent extends MapEvent {
-  constructor(map, loading) {
-    super("loading", map);
-    __publicField$1(this, "loading");
-    this.loading = loading;
-  }
-}
-class MapStyleChangeEvent extends MapEvent {
-  constructor(type, map, oldStyle, newStyle) {
-    super(type, map);
-    __publicField$1(this, "oldStyle");
-    __publicField$1(this, "newStyle");
-    this.oldStyle = oldStyle;
-    this.newStyle = newStyle;
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-Debug__default("flow:map-feature-stream");
-class MapFeatureStream {
-  constructor(options) {
-    __publicField(this, "_boundHandleLoading");
-    __publicField(this, "_boundHandleSourceFeatureState");
-    __publicField(this, "_options");
-    __publicField(this, "_sourceLoadCount", 0);
-    __publicField(this, "_sourceLoaded", true);
-    var _a;
-    this._options = {
-      fireImmediately: true,
-      ...options
-    };
-    const sourceType = options.map.getSource(options.source).type;
-    if (sourceType === "vector")
-      (_a = this._options).sourceLayer ?? (_a.sourceLayer = "geometry");
-    mobx.makeObservable(this, {
-      _options: mobx.observable,
-      _sourceLoadCount: mobx.observable,
-      featureData: mobx.computed.struct
-    });
-    this._boundHandleLoading = this.handleLoading.bind(this);
-    this._boundHandleSourceFeatureState = this.handleSourceFeatureState.bind(this);
-    mobx.onBecomeObserved(this, "featureData", this.resume.bind(this));
-    mobx.onBecomeUnobserved(this, "featureData", this.suspend.bind(this));
-  }
-  // Computed
-  get featureData() {
-    this._sourceLoadCount;
-    const featureData = this.queryFeatureData(this._options.featureIds);
-    return featureData;
-  }
-  get featureIds() {
-    return this._options.featureIds;
-  }
-  set featureIds(featureIds) {
-    mobx.runInAction(() => {
-      this._options.featureIds = featureIds;
-    });
-  }
-  subscribe(handler) {
-    const mobxSubscription = mobxUtils.toStream(() => this.featureData, this._options.fireImmediately).subscribe(handler);
-    return {
-      unsubscribe: () => {
-        mobxSubscription.unsubscribe();
-      }
-    };
-  }
-  featureFromMaplibreFeature(feature) {
-    return {
-      id: feature.id,
-      geometry: feature.geometry,
-      source: this._options.source,
-      sourceLayer: this._options.sourceLayer,
-      properties: feature.properties,
-      state: this._options.map.maplibreMap.getFeatureState({
-        id: feature.id,
-        source: this._options.source,
-        sourceLayer: this._options.sourceLayer
-      })
-    };
-  }
-  handleLoading(event) {
-    let loaded = false;
-    if (event.type === "sourcedata" && event.sourceId === this._options.source) {
-      loaded = event.isSourceLoaded;
-    } else if (event.type === "idle") {
-      loaded = true;
-    }
-    if (this._sourceLoaded !== loaded) {
-      this._sourceLoaded = loaded;
-      if (loaded) {
-        mobx.runInAction(() => {
-          this._sourceLoadCount++;
-        });
-      }
-    }
-  }
-  handleSourceFeatureState(event) {
-    if (event.type === "sourceFeatureState" && event.source === this._options.source) {
-      mobx.runInAction(() => {
-        this._sourceLoadCount++;
-      });
-    }
-  }
-  queryFeatureData(featureIDs) {
-    if (featureIDs.length === 0) {
-      return {};
-    }
-    const featureIdProp = this._options.map.getSource(this._options.source).featureId;
-    let features = this._options.map.maplibreMap.querySourceFeatures(this._options.source, {
-      sourceLayer: this._options.sourceLayer,
-      filter: ["in", ["get", featureIdProp], ["literal", featureIDs]]
-    });
-    const ids = /* @__PURE__ */ new Set();
-    features = features.filter((feature) => ids.has(feature.id) ? false : ids.add(feature.id) && true);
-    const featureData = features.reduce((accum, f) => {
-      accum[f.id] = this.featureFromMaplibreFeature(f);
-      return accum;
-    }, {});
-    return featureData;
-  }
-  resume() {
-    this._options.map.maplibreMap.on("sourcedata", this._boundHandleLoading);
-    this._options.map.maplibreMap.on("idle", this._boundHandleLoading);
-    this._options.map.on("sourceFeatureState", this._boundHandleSourceFeatureState);
-  }
-  suspend() {
-    this._options.map.maplibreMap.off("sourcedata", this._boundHandleLoading);
-    this._options.map.maplibreMap.off("idle", this._boundHandleLoading);
-    this._options.map.off("sourceFeatureState", this._boundHandleSourceFeatureState);
-  }
-}
-
-exports.FlowError = FlowError;
-exports.FlowMapError = FlowMapError;
-exports.MapDataSource = MapDataSource;
-exports.MapEvent = MapEvent;
-exports.MapFeatureStream = MapFeatureStream;
-exports.MapLayer = MapLayer;
-exports.MapLoadingEvent = MapLoadingEvent;
-exports.MapMouseEvent = MapMouseEvent;
-exports.MapSourceEvent = MapSourceEvent;
-exports.MapStyleChangeEvent = MapStyleChangeEvent;
-exports.PluginManager = PluginManager;
-exports.ReactiveExpression = ReactiveExpression;
-exports.assert = assert;
-exports.die = die;