anchor.diff:                //  ## Font size and line height
                 //  ## Padding, margin, border
             section
  -            h1 Top-Level Headings
  -            p.
  -              Use comment blocks to begin and end top-level sections with headings.
  -              Top-level headings are ALL CAPS and preceded with a single hash.
  +            h1 Section and Subsection Headings
  +            p.
  +              Use comment blocks to begin and end sections and subsections with headings.
  +              Section headings are ALL CAPS and preceded by a single hash, while
  +              subsection headings are Title case and follow two hashes.
  +              Only subsections are indented.
               figure: pre.
                 /*++++++++++++++++++++++++++++++++*\
                     # HORIZONTAL GRID
                 \*++++++++++++++++++++++++++++++++*/
                 ... code goes here ...
  +                /*--------------------------------*\
  +                    ## Lines and units
  +                \*--------------------------------*/
  +                ... code goes here ...
  +                //---- end ## Lines and units ----//
                 //++++ end # HORIZONTAL GRID ++++//
  -          section
  -            h1 Low-Level Headings
  -            p.
  -              Also use comment blocks to begin and end low-level sections
  -              (within top-level sections).
  -              Low-level headings are Title case and follow two hashes.
  -            figure: pre.
  -              /*--------------------------------*\
  -                  ## Widths
  -              \*--------------------------------*/
  -              ... code goes here ...
  -              //---- end ## Widths ----//
  
positive.code:               what it is, how it works, when/why it should be used, and its benefits and limitations.
                In this comment it&rsquo;s good practice to also include meta-data such as author and
                date created/modified.
            section
              h1 Developmental
              p.
                These are small, one-line comments explaining why some particular thing was done.
                Use these comments sparingly, for cases in which the code is not obvious;
                too many of these comments can be overwhelming.
                For example, use these when you use #[code !important] in CSS,
                or when you use #[dfn#magic-number magic numbers]&mdash;numbers that just so happen
                to work in their given situation (#[q what does this 18px come from?]).
        section
          h1 Code Organization &amp; File Structure
          section
            h1 CSS Stylesheet Anatomy
            p.
              Every main stylesheet should have the following components, in the order listed,
              at the top of the stylesheet.
            ol
              li repository metadata
              li any direct CSS imports (#[code @import url('*.css')])
              li filename
              li any #[code (reference)] or #[code (inline)] less imports
              li table of contents
            p.
              Furthermore, any stylesheet may have any number of top-level or low-level headings.
            section
              h1 Repository Metadata
              p.
                Include a comment block of information about the repository in the
                repository&rsquo;s main file. This data includes the repo name, latest
                stable version number, licence, URL of the remote repository, the project&rsquo;s
                home page, and author&rsquo;s home page.
              figure: pre.
                /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*\
                    conf
                    Version: 0.1.0
                    Licence: MIT
                    Repo   : https://github.com/asce-web/conf.git
                    Home   : http://conf.style.asce.org/
  
negative.code:               \*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
            section
              h1 Direct CSS Imports
              p These are pure-CSS statements of the following form.
              figure: pre @import url('normalize.css');
              p.
                In a Less file, upon compilation, these lines get moved to the top of the output file
                and remain verbatim, which means no parsing is done (unlike Less imports mentioned below).
              p
                strong Remember:
                |  If you&rsquo;re writing a pure CSS file, put these statments above the metadata block.
              p.
                Though these imports make coding CSS easier, they are not recommended; instead,
                use #[code &lt;link rel="stylesheet" href="normalize.css"/&gt;] at the top of each
                document that uses the would-be-importing stylesheet.
            section
              h1 Filename
              p.
                Put the filename in a comment block after the meta block and any CSS imports.
                The filename for the main stylesheet has a slightly different style than that for the partials.
              figure
                figcaption main stylesheet filename:
                pre.
                  /*================================*\
                      conf.less
                  \*================================*/
              figure
                figcaption partial stylesheet filename (prepended by repo name for clarity):
                pre.
                  /*################################*\
                      conf  |  base.less
                  \*################################*/
            section
              h1 Less Imports
              p.
                You can use #[a(href="http://lesscss.org/features/#import-directives-feature") Less imports],
                reference or inline, to import partials into a main stylesheet.
                These go after the filename comment block, because any code injected inline
                should be done so underneath.
            section
              h1 Table of Contents
              p.
                There are two types of table-of-contents. The first type is used in the main stylesheet
                to describe each imported partial. The second may be used within a partial stylesheet
                to delineate its sections and subsections.
              p.
                A table of contents really helps keep your codebase organized and proides a catalog
                of all the pieces of a project or file. While upkeep maintenance takes some time,
                this can be seen as an investment for a lot of time and confusion saved later on.
              figure: pre.
                /*
                 * # CONTENTS
  