anchor.diff:  A statement is born into a database, and thereafter is not (observably) modified except to remove it.
   Databases are modified by calling methods on the database to insert statements, remove statements, and replace statements with modified versions.
   
  -Statements in SMM are the statements defined in the Metamath specification, plus SMM-specific statement types `COMMENT`, `INCLUDE`, `BOGUS`, and `EOF`;
  +Statements in SMM are the statements defined in the Metamath specification, plus SMM-specific statement types `COMMENT`, `INCLUDE`, `BOGUS`, `METACOMMENT`, and `EOF`;
   these statement types have no effect on the mathematical content of the database, but serve to hold text during parsing that does not naturally correspond to any statement.
   SMM always knows the character data corresponding to a statement.
   It is impossible to create a statement without making *some* decision about the whitespace that would be used to write that statement to a file.
  
positive.code: This is the standard-mode verifier; it does not exploit statement parsing (that works only for set.mm).
  It implements the common error checking protocol but has no other API.
  
  === Errors
  
  ....
  import 'Scoper'
  array_of_errors = database.scoper.errors(statement)
  map_of_errors = database.scoper.allErrors
  
  import 'Verifier'
  array_of_errors = database.verifier.errors(statement)
  map_of_errors = database.verifier.allErrors
  ....
  
  Several analyzers have the capability to generate warnings or errors while analyzing the database.
  These analyzers implement a common API: `errors` fetches a list of errors for a specific statement, `allErrors` fetches a map with error data for each statement with at least one error.
  
      array_of_errors = database.scanner.errors
  
  Scanner errors are reported differently because they cannot generally be linked to a statement.
  
      process.stdout.write( error.toConsoleString(), 'utf8' );
  
  Renders an error as a string containing newlines for human consumption.
  
negative.code: 
  === Parsing
  
  [source]
  import { parseSync } from 'smm/MMOM';
  database = parseSync('filename', '$( file content $)');
  
  Call `parseSync` with two strings to parse a database which is already loaded as a string.
  Returns a `MMOM.Database` instance.
  The filename will be used for error messages (also, `$[` will ignore that filename but give errors for all others).
  Never throws, returns errors in the database object.
  
  [source]
  database = parseSync('file1',
      new Map().set('file1','$[ file2 $]').set('file2',''));
  
  The second argument to `parseSync` may be a `Map` if multiple files are used.
  
  [source]
  database = parseSync('file1', filename => 'foo');
  
  The second argument to `parseSync` may be a function, which will be passed a file name and must return a string or throw an exception.
  Exceptions will be wrapped into `failed-to-read` errors.
  
  [source]
  import { parseAsync } from 'smm/MMOM'
  promise = parseAsync('file1', filename =>
      fetch(filename).then(rpy => rpy.text())).then(db => ... );
  
  `parseAsync` functions like `parseSync` except that only the function form is supported, the function is expected to return a promise, and a promise is returned at the end.
  As `parseSync` never throws, the promise returned from `parseAsync` never rejects.
  