vega-lite-api/build/vega-lite-api.js

A JavaScript API for Vega-Lite.

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vl = {}));
})(this, (function (exports) { 'use strict';

  const Data$1 = Symbol('data');
  const Context = Symbol('context');
  let id_counter = 0;

  function id(prefix) {
    return (prefix || '') + (++id_counter);
  }

  class BaseObject {
    toObject() { return toObject(this); }
  }

  class MergeObject {
    constructor(values) { this[Data$1] = values; }
    toObject() { return Object.assign({}, ...recurse(this[Data$1])); }
  }

  function assign(target, ...sources) {
    if (sources.length === 1 && Array.isArray(sources[0])) {
      target[Data$1] = sources[0];
    } else {
      sources.forEach(s => {
        Object.assign(target[Data$1], isObject(s) && s[Data$1] || s);
      });
    }
    return target;
  }

  function flat(value) {
    return Array.isArray(value) ? [].concat(...value) : value;
  }

  function prop(obj, name) {
    return isObject(obj) && !obj[Data$1] ? obj[name] : get(obj, name);
  }

  function get(obj, name) {
    return obj[Data$1][name];
  }

  function set(obj, name, value) {
    obj[Data$1][name] = object(value);
  }

  function duplicate(...obj) {
    return Object.assign(
      Object.create(Object.getPrototypeOf(obj[0])),
      ...obj
    );
  }

  function copy(obj) {
    return duplicate(obj, { [Data$1]: Object.assign({}, obj[Data$1]) });
  }

  function init(obj, value) {
    obj[Data$1] = value || {};
  }

  function annotate(value, context) {
    const ctx = { [Context]: context };
    return isArray(value)
      ? value.map(v => duplicate(v, ctx))
      : duplicate(value, ctx)
  }

  function recurse(d) {
    return d && d.toObject ? d.toObject(d[Context] || 0) : toObject(d);
  }

  function toObject(value) {
    if (isArray(value)) {
      return value.map(d => recurse(d));
    } else if (isObject(value)) {
      const data = value[Data$1] || value;
      return isArray(data)
        ? recurse(data)
        : Object.keys(data).reduce((_, k) => {
            _[k] = recurse(data[k]);
            return _;
          }, {});
    } else {
      return value;
    }
  }

  function raw(value) {
    return { [Data$1]: value, toObject: () => value };
  }

  function object(value) {
    return (isObject(value) && !value[Data$1]) ? {[Data$1]: value || {}} : value;
  }

  function merge(flag, ...values) {
    const objects = [].concat(...values);
    return new MergeObject(flag ? annotate(objects, flag) : objects);
  }

  function nest(obj, keys, rest) {
    const m = keys.reduce((m, k) => (m[k] = 1, m), {}),
          u = {}, v = {};

    for (let k in obj) (m[k] ? u : v)[k] = obj[k];
    u[rest] = v;
    return u;
  }

  // -- type checkers --

  const isArray = Array.isArray;

  function isIterable(_) {
    return isObject(_) && typeof _[Symbol.iterator] === 'function';
  }

  function isObject(_) {
    return _ === Object(_) && !isArray(_);
  }

  function isString(_) {
    return typeof _ === 'string';
  }

  function isFunction(_) {
    return typeof _ === 'function';
  }

  function isEventTarget(_) {
    return isObject(_) && isFunction(_.addEventListener);
  }

  exports.vegalite = void 0;
  exports.vega = void 0;
  var _opt;

  // TODO: validation

  function options(...viewopt) {
    const opt = Object.assign({}, _opt);
    opt.view = Object.assign({}, _opt.view, ...viewopt);
    if (opt.view.spec) {
      opt.spec = opt.view.spec;
      delete opt.view.spec;
    }
    return opt;
  }

  function element() {
    return typeof document === 'undefined' ? undefined
      : document.createElement('div');
  }

  function createSpec(self) {
    const major = exports.vegalite ? exports.vegalite.version.split('.')[0] : '5';
    return Object.assign(
      {$schema: `https://vega.github.io/schema/vega-lite/v${major}.json`},
      self.toObject()
    );
  }

  function createView(self, opt) {
    if (!exports.vegalite || !exports.vega) {
      throw Error('Vega / Vega-Lite not registered. Use the "register" method.');
    }

    const spec = exports.vegalite.compile(opt.spec || createSpec(self), opt.config),
          view = new exports.vega.View(exports.vega.parse(spec.spec), opt.view);

    if (opt.init) opt.init(view);

    return view;
  }

  async function render(opt) {
    opt = options({container: opt && opt.container || element()}, opt);

    const view = await createView(this, opt).runAsync(),
          div = view.container() || {};

    div.value = view;
    return div;
  }

  function toView(opt) {
    return createView(this, options(opt));
  }

  function toSpec() {
    return createSpec(this);
  }

  function toString(space) {
    return JSON.stringify(createSpec(this), null, space);
  }

  function register(vega, vegalite, options) {
    exports.vegalite = vegalite;
    exports.vega = vega;
    _opt = options || {};
    return this;
  }

  class _Repeat extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      if (args[0] !== undefined) set(this, "repeat", args[0]);
      if (args[1] !== undefined) set(this, "spec", args[1]);
    }

    align(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "align", value);
        return obj;
      } else {
        return get(this, "align");
      }
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    columns(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "columns", value);
        return obj;
      } else {
        return get(this, "columns");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    spec(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spec", value);
        return obj;
      } else {
        return get(this, "spec");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function _repeat(...args) {
    return new _Repeat(...args);
  }

  class _Facet extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      if (args[0] !== undefined) set(this, "facet", args[0]);
      if (args[1] !== undefined) set(this, "spec", args[1]);
    }

    align(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "align", value);
        return obj;
      } else {
        return get(this, "align");
      }
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    columns(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "columns", value);
        return obj;
      } else {
        return get(this, "columns");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    spec(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spec", value);
        return obj;
      } else {
        return get(this, "spec");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function _facet(...args) {
    return new _Facet(...args);
  }

  class Mark extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      args = args.map(_ => isString(_) ? {type: _} : _);
      set(this, "mark", merge(0, get(this, "mark"), args));
    }

    align(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "align", value);
        return obj;
      } else {
        return get(this, "align");
      }
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    height(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "height", value);
        return obj;
      } else {
        return get(this, "height");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    view(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "view", value);
        return obj;
      } else {
        return get(this, "view");
      }
    }

    width(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "width", value);
        return obj;
      } else {
        return get(this, "width");
      }
    }

    mark(...values) {
      if (arguments.length) {
        values = values.map(v => isString(v) ? {type: v} : v);
        const obj = copy(this);
        set(obj, "mark", merge(0, values));
        return obj;
      } else {
        return get(this, "mark");
      }
    }

    select(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    project(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "projection", value);
        return obj;
      } else {
        return get(this, "projection");
      }
    }

    encode(...values) {
      if (values.length === 1 && Array.isArray(values[0])) {
        values = values[0];
      }
      if (values.length) {
        const val = get(this, "encoding");
        const obj = copy(this);
        if (val) values = [val].concat(values);
        set(obj, "encoding", merge(1, values));
        return obj;
      } else {
        return get(this, "encoding");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    markArc(...values) {
      values = [{"type":"arc"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markArea(...values) {
      values = [{"type":"area"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markBar(...values) {
      values = [{"type":"bar"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markBoxplot(...values) {
      values = [{"type":"boxplot"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markCircle(...values) {
      values = [{"type":"circle"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markErrorband(...values) {
      values = [{"type":"errorband"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markErrorbar(...values) {
      values = [{"type":"errorbar"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markGeoshape(...values) {
      values = [{"type":"geoshape"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markImage(...values) {
      values = [{"type":"image"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markLine(...values) {
      values = [{"type":"line"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markPoint(...values) {
      values = [{"type":"point"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markRect(...values) {
      values = [{"type":"rect"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markRule(...values) {
      values = [{"type":"rule"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markSquare(...values) {
      values = [{"type":"square"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markText(...values) {
      values = [{"type":"text"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markTick(...values) {
      values = [{"type":"tick"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    markTrail(...values) {
      values = [{"type":"trail"}].concat(values);
      const obj = copy(this);
      set(obj, "mark", merge(0, values));
      return obj;
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function mark(...args) {
    return new Mark(...args);
  }

  function markArc(...args) {
    return mark({"type":"arc"}, ...args);
  }

  function markArea(...args) {
    return mark({"type":"area"}, ...args);
  }

  function markBar(...args) {
    return mark({"type":"bar"}, ...args);
  }

  function markBoxplot(...args) {
    return mark({"type":"boxplot"}, ...args);
  }

  function markCircle(...args) {
    return mark({"type":"circle"}, ...args);
  }

  function markErrorband(...args) {
    return mark({"type":"errorband"}, ...args);
  }

  function markErrorbar(...args) {
    return mark({"type":"errorbar"}, ...args);
  }

  function markGeoshape(...args) {
    return mark({"type":"geoshape"}, ...args);
  }

  function markImage(...args) {
    return mark({"type":"image"}, ...args);
  }

  function markLine(...args) {
    return mark({"type":"line"}, ...args);
  }

  function markPoint(...args) {
    return mark({"type":"point"}, ...args);
  }

  function markRect(...args) {
    return mark({"type":"rect"}, ...args);
  }

  function markRule(...args) {
    return mark({"type":"rule"}, ...args);
  }

  function markSquare(...args) {
    return mark({"type":"square"}, ...args);
  }

  function markText(...args) {
    return mark({"type":"text"}, ...args);
  }

  function markTick(...args) {
    return mark({"type":"tick"}, ...args);
  }

  function markTrail(...args) {
    return mark({"type":"trail"}, ...args);
  }

  class Layer extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      args = flat(args);
      set(this, "layer", args);
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    height(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "height", value);
        return obj;
      } else {
        return get(this, "height");
      }
    }

    layer(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "layer", value);
        return obj;
      } else {
        return get(this, "layer");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    view(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "view", value);
        return obj;
      } else {
        return get(this, "view");
      }
    }

    width(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "width", value);
        return obj;
      } else {
        return get(this, "width");
      }
    }

    project(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "projection", value);
        return obj;
      } else {
        return get(this, "projection");
      }
    }

    encode(...values) {
      if (values.length === 1 && Array.isArray(values[0])) {
        values = values[0];
      }
      if (values.length) {
        const val = get(this, "encoding");
        const obj = copy(this);
        if (val) values = [val].concat(values);
        set(obj, "encoding", merge(1, values));
        return obj;
      } else {
        return get(this, "encoding");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function layer(...args) {
    return new Layer(...args);
  }

  class Concat extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      args = flat(args);
      set(this, "concat", args);
    }

    align(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "align", value);
        return obj;
      } else {
        return get(this, "align");
      }
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    columns(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "columns", value);
        return obj;
      } else {
        return get(this, "columns");
      }
    }

    concat(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "concat", value);
        return obj;
      } else {
        return get(this, "concat");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function concat(...args) {
    return new Concat(...args);
  }

  class Hconcat extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      args = flat(args);
      set(this, "hconcat", args);
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    hconcat(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "hconcat", value);
        return obj;
      } else {
        return get(this, "hconcat");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function hconcat(...args) {
    return new Hconcat(...args);
  }

  class Vconcat extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      args = flat(args);
      set(this, "vconcat", args);
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    vconcat(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "vconcat", value);
        return obj;
      } else {
        return get(this, "vconcat");
      }
    }

    data(value) {
      if (arguments.length) {
        const obj = copy(this);
        value = isArray(value) ? {values: raw(value)} : isIterable(value) ? {values: raw(value)} : isString(value) ? {url: value} : value;
        set(obj, "data", value);
        return obj;
      } else {
        return get(this, "data");
      }
    }

    params(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        value = annotate(value, 1);
        set(obj, "params", value);
        return obj;
      } else {
        return get(this, "params");
      }
    }

    transform(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "transform", value);
        return obj;
      } else {
        return get(this, "transform");
      }
    }

    facet(...values) {
      values = values.slice(0, 1);
      const obj = _facet(...values);
      return obj.spec(this);
    }

    repeat(...values) {
      values = values.slice(0, 1);
      const obj = _repeat(...values);
      return obj.spec(this);
    }

    render(...values) {
      return render.apply(this, values);
    }

    toView(...values) {
      return toView.apply(this, values);
    }

    toSpec(...values) {
      return toSpec.apply(this, values);
    }

    toString(...values) {
      return toString.apply(this, values);
    }

  }

  function vconcat(...args) {
    return new Vconcat(...args);
  }

  class Spec extends BaseObject {

    constructor(...args) {
      super();
      init(this);
      assign(this, ...args);
    }

    align(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "align", value);
        return obj;
      } else {
        return get(this, "align");
      }
    }

    autosize(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "autosize", value);
        return obj;
      } else {
        return get(this, "autosize");
      }
    }

    background(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "background", value);
        return obj;
      } else {
        return get(this, "background");
      }
    }

    bounds(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "bounds", value);
        return obj;
      } else {
        return get(this, "bounds");
      }
    }

    center(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "center", value);
        return obj;
      } else {
        return get(this, "center");
      }
    }

    config(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "config", value);
        return obj;
      } else {
        return get(this, "config");
      }
    }

    datasets(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "datasets", value);
        return obj;
      } else {
        return get(this, "datasets");
      }
    }

    description(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "description", value);
        return obj;
      } else {
        return get(this, "description");
      }
    }

    encoding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "encoding", value);
        return obj;
      } else {
        return get(this, "encoding");
      }
    }

    height(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "height", value);
        return obj;
      } else {
        return get(this, "height");
      }
    }

    mark(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "mark", value);
        return obj;
      } else {
        return get(this, "mark");
      }
    }

    name(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "name", value);
        return obj;
      } else {
        return get(this, "name");
      }
    }

    padding(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "padding", value);
        return obj;
      } else {
        return get(this, "padding");
      }
    }

    projection(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "projection", value);
        return obj;
      } else {
        return get(this, "projection");
      }
    }

    resolve(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "resolve", value);
        return obj;
      } else {
        return get(this, "resolve");
      }
    }

    spacing(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spacing", value);
        return obj;
      } else {
        return get(this, "spacing");
      }
    }

    title(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "title", value);
        return obj;
      } else {
        return get(this, "title");
      }
    }

    usermeta(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "usermeta", value);
        return obj;
      } else {
        return get(this, "usermeta");
      }
    }

    view(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "view", value);
        return obj;
      } else {
        return get(this, "view");
      }
    }

    width(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "width", value);
        return obj;
      } else {
        return get(this, "width");
      }
    }

    columns(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "columns", value);
        return obj;
      } else {
        return get(this, "columns");
      }
    }

    spec(value) {
      if (arguments.length) {
        const obj = copy(this);
        set(obj, "spec", value);
        return obj;
      } else {
        return get(this, "spec");
      }
    }

    layer(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "layer", value);
        return obj;
      } else {
        return get(this, "layer");
      }
    }

    concat(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "concat", value);
        return obj;
      } else {
        return get(this, "concat");
      }
    }

    vconcat(...value) {
      if (arguments.length) {
        const obj = copy(this);
        value = flat(value);
        set(obj, "vconcat", value);
        retur