_do(geometry, graph_view, final, append) {
    const [node_view, edge_view] = [graph_view.node_view, graph_view.edge_view];
    const hit_test_result = node_view.glyph.hit_test(geometry);

    // glyphs that don't have hit-testing implemented will return null
    if (hit_test_result === null) {
      return false;
    }

    this._node_selector.update(hit_test_result, final, append);

    const node_indices = ((() => {
      const result = [];
      for (const i of hit_test_result["1d"].indices) {
        result.push(node_view.model.data_source.data.index[i]);
      }
      return result;
    })());
    const edge_source = edge_view.model.data_source;
    const edge_indices = [];
    for (let i = 0, end = edge_source.data.start.length; i < end; i++) {
      if (includes(node_indices, edge_source.data.start[i]) || includes(node_indices, edge_source.data.end[i])) {
        edge_indices.push(i);
      }
    }

    const linked_index = create_hit_test_result();
    for (const i of edge_indices) {
      linked_index["2d"].indices[i] = [0];
    } //currently only supports 2-element multilines, so this is all of it

    this._edge_selector.update(linked_index, final, append);

    return !this._node_selector.indices.is_empty();
  }

  initialize(options: any): void {
    super.initialize(options);

    const base_glyph = this.model.glyph;
    const has_fill = includes(base_glyph.mixins, "fill");
    const has_line = includes(base_glyph.mixins, "line");
    const glyph_attrs = clone(base_glyph.attributes);
    delete glyph_attrs.id;

    const mk_glyph = function(defaults) {
      const attrs = clone(glyph_attrs);
      if (has_fill) { extend(attrs, defaults.fill); }
      if (has_line) { extend(attrs, defaults.line); }
      return new (base_glyph.constructor as any)(attrs);
    };

    this.glyph = this.build_glyph_view(base_glyph);

    let { selection_glyph } = this.model;
    if ((selection_glyph == null)) {
      selection_glyph = mk_glyph({fill: {}, line: {}});
    } else if (selection_glyph === "auto") {
      selection_glyph = mk_glyph(this.model.selection_defaults);
    }
    this.selection_glyph = this.build_glyph_view(selection_glyph);

    let { nonselection_glyph } = this.model;
    if ((nonselection_glyph == null)) {
      nonselection_glyph = mk_glyph({fill: {}, line: {}});
    } else if (nonselection_glyph === "auto") {
      nonselection_glyph = mk_glyph(this.model.nonselection_defaults);
    }
    this.nonselection_glyph = this.build_glyph_view(nonselection_glyph);

    const { hover_glyph } = this.model;
    if (hover_glyph != null) {
      this.hover_glyph = this.build_glyph_view(hover_glyph);
    }

    const { muted_glyph } = this.model;
    if (muted_glyph != null) {
      this.muted_glyph = this.build_glyph_view(muted_glyph);
    }

    const decimated_glyph = mk_glyph(this.model.decimated_defaults);
    this.decimated_glyph = this.build_glyph_view(decimated_glyph);

    this.xscale = this.plot_view.frame.xscales[this.model.x_range_name];
    this.yscale = this.plot_view.frame.yscales[this.model.y_range_name];

    this.set_data(false);

    if (this.model.data_source instanceof RemoteDataSource) {
      return this.model.data_source.setup();
    }
  }

  initialize(options: any): void {
    super.initialize(options)

    const base_glyph = this.model.glyph
    const has_fill = includes(base_glyph.mixins, "fill")
    const has_line = includes(base_glyph.mixins, "line")
    const glyph_attrs = clone(base_glyph.attributes)
    delete glyph_attrs.id

    function mk_glyph(defaults: Defaults): typeof base_glyph {
      const attrs = clone(glyph_attrs)
      if (has_fill) extend(attrs, defaults.fill)
      if (has_line) extend(attrs, defaults.line)
      return new (base_glyph.constructor as any)(attrs)
    }

    this.glyph = this.build_glyph_view(base_glyph)

    let {selection_glyph} = this.model
    if (selection_glyph == null)
      selection_glyph = mk_glyph({fill: {}, line: {}})
    else if (selection_glyph === "auto")
      selection_glyph = mk_glyph(selection_defaults)
    this.selection_glyph = this.build_glyph_view(selection_glyph)

    let {nonselection_glyph} = this.model
    if ((nonselection_glyph == null))
      nonselection_glyph = mk_glyph({fill: {}, line: {}})
    else if (nonselection_glyph === "auto")
      nonselection_glyph = mk_glyph(nonselection_defaults)
    this.nonselection_glyph = this.build_glyph_view(nonselection_glyph)

    const {hover_glyph} = this.model
    if (hover_glyph != null)
      this.hover_glyph = this.build_glyph_view(hover_glyph)

    const {muted_glyph} = this.model
    if (muted_glyph != null)
      this.muted_glyph = this.build_glyph_view(muted_glyph)

    const decimated_glyph = mk_glyph(decimated_defaults)
    this.decimated_glyph = this.build_glyph_view(decimated_glyph)

    this.xscale = this.plot_view.frame.xscales[this.model.x_range_name]
    this.yscale = this.plot_view.frame.yscales[this.model.y_range_name]

    this.set_data(false)

    if (this.model.data_source instanceof RemoteDataSource)
      this.model.data_source.setup()
  }

  retain_neighbors(reference_tile) {
    const neighbor_radius = 4;
    const [tx, ty, tz] = reference_tile.tile_coords;
    const neighbor_x = (range(tx - neighbor_radius, tx + neighbor_radius+1));
    const neighbor_y = (range(ty - neighbor_radius, ty + neighbor_radius+1));

    for (const key in this.tiles) {
      const tile = this.tiles[key];
      if (tile.tile_coords[2] === tz && includes(neighbor_x, tile.tile_coords[0])
                                     && includes(neighbor_y, tile.tile_coords[1])) {
        tile.retain = true;
      }
    }
  }

  render(): void {
    super.render()
    empty(this.el)

    const active = this.model.active
    const labels = this.model.labels

    for (let i = 0; i < labels.length; i++) {
      const text = labels[i]

      const inputEl = input({type: `checkbox`, value: `${i}`})
      inputEl.addEventListener("change", () => this.change_input())

      if (this.model.disabled)
        inputEl.disabled = true

      if (includes(active, i))
        inputEl.checked = true

      const labelEl = label({}, inputEl, text)
      if (this.model.inline) {
        labelEl.classList.add("bk-bs-checkbox-inline")
        this.el.appendChild(labelEl)
      } else {
        const divEl = div({class: "bk-bs-checkbox"}, labelEl)
        this.el.appendChild(divEl)
      }
    }
  }

 const inspected_subset_indices: number[] = ((() => {
   const result = []
   for (const i of indices) {
     if (includes(inspected_full_indices, this.all_indices[i]))
       result.push(i)
   }
   return result
 })())

 inspected = ((() => {
   const result = [];
   for (const i of indices) {
     if (includes(inspected, this.all_indices[i])) {
       result.push(i);
     }
   }
   return result;
 })());

 protected _check_field_label_on_data_source(): boolean {
   const field = this.get_field_from_label_prop()
   if (field != null) {
     if (this.renderers.length < 1) {
       return false
     }
     const source = this.renderers[0].data_source
     if (source != null && !includes(source.columns(), field)) {
       return false
     }
   }
   return true
 }

  change_input(i: number): void {
    const active = copy(this.active)

    if (includes(active, i))
      removeBy(active, (j) => i == j)
    else
      active.push(i)

    active.sort()

    this.active = active

    if (this.callback != null)
      this.callback.execute(this)
  }

 update_selection(selection) {
   for (const renderer of this.model.plot.renderers) {
     if (!(renderer instanceof GlyphRenderer)) {
       continue;
     }
     const ds = renderer.data_source;
     if (selection != null) {
       if (includes(selection, renderer.id)) {
         ds.selected = selection[renderer.id];
       }
     } else {
       ds.selection_manager.clear();
     }
   }
 }