anchor.diff:  (in-package :ps)
  -;;;# Introduction
  +
  +;;; Introduction
   ;;;
  -;;; ParenScript is a simple language that looks a lot like Lisp, but
  -;;; actually is JavaScript in disguise. Actually, it is JavaScript
  -;;; embedded in a host Lisp. This way, JavaScript programs can be
  +;;; Parenscript is a language that looks a lot like Common Lisp, but
  +;;; is JavaScript in disguise. This way, JavaScript programs can be
   ;;; seamlessly integrated in a Lisp web application. The programmer
   ;;; doesn't have to resort to a different syntax, and JavaScript code
   ;;; can easily be generated without having to resort to complicated
   ;;; string generation or `FORMAT' expressions.
   ;;;
  -;;; An example is worth more than a thousand words. The following Lisp
  -;;; expression is a call to the ParenScript "compiler". The
  -;;; ParenScript "compiler" transforms the expression in ParenScript
  +;;; The following Lisp expression is a call to the Parenscript
  +;;; translator Parenscript transforms the expression in Parenscript
   ;;; into an equivalent, human-readable expression in JavaScript.
   
   (ps
     (defun foobar (a b)
  -    (return (+ a b))))
  +    (+ a b)))
   
   ;;; The resulting javascript is:
  +
   "
   function foobar(a, b) {
     return a + b;
   }
   "
  +
   ;;; Great care has been given to the indentation and overall
   ;;; readability of the generated JavaScript code.
   
  -;;;# Features
  +;;; Features
   ;;;
  -;;; ParenScript supports all the statements and expressions defined by
  +;;; Parenscript supports all the statements and expressions defined by
   ;;; the EcmaScript 262 standard. Lisp symbols are converted to
   ;;; camelcase, javascript-compliant syntax. This idea is taken from
  -;;; Linj by Antonio Menezes Leitao.  Here are a few examples of Lisp
  -;;; symbol to JavaScript name conversion:
  +;;; Linj by Antonio Menezes Leitao. Case sensitivity (using the
  +;;; :invert readtable-case option) is supported. Here are a few
  +;;; examples of Lisp symbol to JavaScript name conversion:
   
  -(js-to-string 'foobar)      => "foobar"
  -(js-to-string 'foo-bar)     => "fooBar"
  -(js-to-string 'foo-b-@-r)   => "fooBAtR"
  -(js-to-string 'foo-b@r)     => "fooBatr"
  -(js-to-string '*array)      => "Array"
  -(js-to-string '*math.floor) => "Math.floor"
  +(ps foobar)      => "foobar"
  +(ps foo-bar)     => "fooBar"
  +(ps foo-b@r)     => "fooBatr"
  +(ps *array)      => "Array"
  +(ps FooBar)      => "FooBar"
   
  -;;; It also supports additional iteration constructs, relieving the
  -;;; programmer of the burden of iterating over arrays.
  +;;; Parenscript supports a subset of Common Lisp iteration constructs.
   ;;; `for' loops can be written using the customary `DO*' syntax.
   
   (ps
  
positive.code: { foo : 'foo',
    bla : 'bla' }
  "
  ;;; ParenScript features a HTML generator. Using the same syntax as
  ;;; the HTMLGEN package of Franz, Inc., it can generate JavaScript
  ;;; string expressions. This allows for a clean integration of HTML in
  ;;; ParenScript code, instead of writing the tedious and error-prone
  ;;; string generation code generally found in JavaScript.
  
  (ps
  
negative.code:   alert('i is ' + i + ' and j is ' + j);
  };
  "
  ;;; Parenscript uses the Lisp reader, allowing for reader macros. It
  ;;; also comes with its own macro environment, allowing host Lisp
  ;;; macros and Parenscript macros to coexist without interfering with
  ;;; each other.  For example, the `1+' construct is implemented using
  ;;; a Parenscript macro:
  
  (defpsmacro 1+ (form)
    `(+ ,form 1))
  
  ;;; Parenscript allows the creation of JavaScript objects in a Lispy
  ;;; way, using keyword arguments.
  
  (ps
  