anchor.diff:    /**
      * Requests the isolate to pause.
      *
  -   * The isolate should stop handling events by pausing its event queue.
  -   * The request will eventually make the isolate stop doing anything.
  -   * It will be handled before any other messages that are later sent to the
  -   * isolate from the current isolate, but no other guarantees are provided.
  -   *
  -   * The event loop may be paused before previously sent, but not yet exeuted,
  -   * messages have been reached.
  +   * When the isolate receives the pause command, it stops
  +   * processing events from the event loop queue.
  +   * It may still add new events to the queue in response to, e.g., timers
  +   * or receive-port messages. When the isolate is resumed, it handles
  +   * the already enqueued events.
  +   *
  +   * The pause request is sent through the isolate's command port,
  +   * which bypasses the receiving isolate's event loop.
  +   * The pause takes effect when it is received, pausing the event loop
  +   * as it is at that time.
      *
      * If [resumeCapability] is provided, it is used to identity the pause,
      * and must be used again to end the pause using [resume].
  
positive.code:    * Creates and spawns an isolate that shares the same code as the current
     * isolate.
     *
     * The argument [entryPoint] specifies the entry point of the spawned
     * isolate. It must be a top-level function or a static method that
     * takes one argument - that is, one-parameter functions that can be
     * compile-time constant function values.
     * It is not allowed to pass the value of function expressions or an instance
     * method extracted from an object.
     *
     * The entry-point function is invoked with the initial [message].
     * Usually the initial [message] contains a [SendPort] so
     * that the spawner and spawnee can communicate with each other.
     *
     * If the [paused] parameter is set to `true`,
     * the isolate will start up in a paused state,
     * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
     * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
     *
  
negative.code:    * corresponding parameter and was processed before the isolate starts
     * running.
     *
     * If [errorsAreFatal] is omitted, the platform may choose a default behavior
     * or inherit the current isolate's behavior.
     *
     * You can also call the [setErrorsFatal], [addOnExitListener] and
     * [addErrorListener] methods on the returned isolate, but unless the
     * isolate was started as [paused], it may already have terminated
     * before those methods can complete.
     *
     * Returns a future which will complete with an [Isolate] instance if the
     * spawning succeeded. It will complete with an error otherwise.
     */
    external static Future<Isolate> spawn(void entryPoint(message), var message,
                                          {bool paused: false,
                                           bool errorsAreFatal,
                                           SendPort onExit,
                                           SendPort onError});
  
    /**
     * Creates and spawns an isolate that runs the code from the library with
  