return value != null && value !== 0 && value !== "#000000";

  }

    log("  _addEffectSetting", deviceAttr.value, value);

    const U = (x: string) => this.graph.Uri(x);

    const quad = (s: Quad_Subject, p: Quad_Predicate, o: Quad_Object) => this.graph.Quad(s, p, o, this.ctxForEffect);

    return this.graph.getObjectPatch(

      effectSetting, //

      valuePred(this.graph, deviceAttr),

      this.ctxForEffect

    );

  }

    const U = (x: string) => this.graph.Uri(x);

    log("  _removeEffectSetting", effectSetting.value);

    const toDel = [this.graph.Quad(this.uri, U(":setting"), effectSetting, this.ctxForEffect)];

    return new Patch(toDel, []);

  }

    if (value === null) {

      throw new Error("no value");

    }

    getTopGraph().then((g) => {

      this.graph = g;

      this.setEffectFromUrl();

    });

  }

  // Note that this doesn't fetch setting values, so it only should get rerun

  // upon (rarer) changes to the devices etc. todo: make that be true

    const U = this.graph.U();

    // if (patch && !patchContainsPreds(patch, [U("rdf:type")])) {

    //   return;

    }

  }

  // handler might have no watches, in which case we could forget about it

    log("handler tree:");

    var prn = function (h: Handler, depth: number) {

      let indent = "";

import { AutoDependencies, HandlerFunc } from "./AutoDependencies";

import { Patch, patchToDeleteEntireGraph } from "./patch";

import { RdfDbClient } from "./rdfdbclient";

const log = debug("graph");

const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";

export class SyncedGraph {

  private graph: N3.Store;

  private prefixFuncs: (prefix: string) => N3.PrefixedToIri;

  // Main graph object for a browser to use. Consider using RdfdbSyncedGraph element to create & own

  // one of these. Syncs both ways with rdfdb. Meant to hide the choice of RDF lib, so we can change it

  // later.

  // it can fire subscriptions.

  constructor(

    // prefixes can be used in Uri(curie) calls. This mapping may grow during loadTrig calls.

    public prefixes: Map<string, string>,

    // called if we clear the graph

    private clearCb: any

  ) {

    this.prefixFuncs = this.rebuildPrefixFuncs(prefixes);

    this.graph = new N3.Store();

    this.clearGraph();

  }

  clearGraph() {

    // just deletes the statements; watchers are unaffected.

    this.cachedFloatValues = new Map(); // s + '|' + p -> number

    this.cachedUriValues = new Map(); // s + '|' + p -> Uri

  }

  _clearGraphOnNewConnection() {

    log("clearGraphOnNewConnection");

    this.clearGraph();

    log("clearGraphOnNewConnection done");

  applyAndSendPatch(patch: Patch) {

    console.time("applyAndSendPatch");

      log("not connected-- dropping patch");

      return;

    }

    this._applyPatch(patch);

    }

    console.timeEnd("applyAndSendPatch");

  }

    this.serial += 1;

    //label = label + @serial

  }

  _singleValue(s: Quad_Subject, p: Quad_Predicate) {

    const quads = this.graph.getQuads(s, p, null, null);

    const objs = new Set(Array.from(quads).map((q: Quad) => q.object));

  }

  objects(s: any, p: any): Quad_Object[] {

    const quads = this.graph.getQuads(s, p, null, null);

    return Array.from(quads).map((q: { object: any }) => q.object);

  }

  subjects(p: any, o: any): Quad_Subject[] {

    const quads = this.graph.getQuads(null, p, o, null);

    return Array.from(quads).map((q: { subject: any }) => q.subject);

  }

  subjectStatements(s: Quad_Subject): Quad[] {

    const quads = this.graph.getQuads(s, null, null, null);

    return quads;

  }

        break;

      }

      const firsts = this.graph.getQuads(current, RDF + "first", null, null);

      const rests = this.graph.getQuads(current, RDF + "rest", null, null);

  }

  contains(s: any, p: any, o: any): boolean {

    // Sure this is a nice warning to remind me to rewrite, but the graph.size call itself was taking 80% of the time in here

    // log("contains calling getQuads when graph has ", this.graph.size);

    return this.graph.getQuads(s, p, o, null).length > 0;

    const results = [];

    // @contains is really slow.

    }

    if (start === undefined) {

      start = 0;

    }

      if (!this.contains(uri, null, null)) {

        results.push(uri);

        log("nextNumberedResources", `picked ${uri}`);

        if (results.length >= howMany) {

          return results;

        }

  }

  contextsWithPattern(s: any, p: any, o: any) {

    const ctxs = [];

    for (let q of Array.from(this.graph.getQuads(s, p, o, null))) {

      ctxs.push(q.graph);