anchor.diff:    }
   
     // these are filled lazily the first time the isolate starts running.
  -  void initGlobals() native r'$initGlobals(this);';
  +  void initGlobals() { JS("void", r'$initGlobals(#)', this); }
   
     /**
      * Run [code] in the context of the isolate represented by [this]. Note this
  
positive.code:    * The src url for the script tag that loaded this code. Used to create
     * JavaScript workers.
     */
    static String get _thisScript() native r"return $thisScriptUrl";
  
    /** Starts a new worker with the given URL. */
    static _WorkerStub _newWorker(url) native "return new Worker(url);";
  
    /**
     * Assume that [e] is a browser message event and extract its message data.
     * We don't import the dom explicitly so, when workers are disabled, this
     * library can also run on top of nodejs.
     */
    static _getEventData(e) native "return e.data";
  
    /**
     * Process messages on a worker, either to control the worker instance or to
  
negative.code:     }
    }
  
    static void _consoleLog(msg) {
      JS("void", r"$globalThis.console.log(#)", msg);
    }
  
    /**
     * Extract the constructor of runnable, so it can be allocated in another
     * isolate.
     */
    static Dynamic _getJSConstructor(Isolate runnable) {
      return JS("Object", "#.constructor", runnable);
    }
  
    /** Extract the constructor name of a runnable */
    // TODO(sigmund): find a browser-generic way to support this.
    // TODO(floitsch): is this function still used? If yes, should we use
    // Primitives.objectTypeName instead?
    static Dynamic _getJSConstructorName(Isolate runnable) {
      return JS("Object", "#.constructor.name", runnable);
    }
  
    /** Find a constructor given its name. */
    static Dynamic _getJSConstructorFromName(String factoryName) {
      return JS("Object", r"$globalThis[#]", factoryName);
    }
  
    static Dynamic _getJSFunctionFromName(String functionName) {
      return JS("Object", r"$globalThis[#]", functionName);
    }
  
    /**
     * Get a string name for the function, if possible.  The result for
     * anonymous functions is browser-dependent -- it may be "" or "anonymous"
     * but you should probably not count on this.
     */
    static String _getJSFunctionName(Function f) {
      return JS("Object", r"(#.$name || #)", f, null);
    }
  
    /** Create a new JavaScript object instance given its constructor. */
    static Dynamic _allocate(var ctor) {
      return JS("Object", "new #()", ctor);
    }
  
    // TODO(sigmund): clean up above, after we make the new API the default:
  
  