anchor.diff:     * 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 that will complete with an [Isolate] instance if the
  +   * 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 });
  +                                        {bool paused: false,
  +                                         bool errorsAreFatal,
  +                                         SendPort onExit,
  +                                         SendPort onError});
   
     /**
      * Creates and spawns an isolate that runs the code from the library with
  
positive.code:    * that was requested using the [resumeCapability].
     *
     * When all active pause requests have been cancelled, the isolate
     * will continue handling normal messages.
     *
     * The capability must be one returned by a call to [pause] on this
     * isolate, otherwise the resume call does nothing.
  
negative.code:    * only one resume with that capability is needed to end the pause.
     *
     * If an isolate is paused using more than one capability,
     * each pause must be individually ended before the isolate resumes.
     *
     * Returns the capability that must be used to end the pause.
     */
    Capability pause([Capability resumeCapability]) {
      resumeCapability ??= new Capability();
      _pause(resumeCapability);
      return resumeCapability;
    }
  