Header...

^|(?<=[\s>$pnct\(])|[{[])
                    (?P$tag)(?!$tag)
                    (?P{$this->cls})
                    (?!$tag)
                    (?::(?P\S+[^$tag]{$this->regex_snippets['space']}))?
                    (?P[^{$this->regex_snippets['space']}$tag]+|\S.*?[^\s$tag\n])
                    (?P[$pnct]*)
                    $tag
                    (?P$|[\[\]}<]|(?=[$pnct]{1,2}[^0-9]|\s|\)))
                    /x".$this->regex_snippets['mod'],
                    array(&$this, "fSpan"),
                    $text
                );
            }
        }
        $this->span_depth--;
        return $text;
    }

    /**
     * Formats a span tag and stores it on the shelf.
     *
     * @param  array  $m Options
     * @return string Content wrapped to reference tokens
     * @see    Parser::spans()
     */

    protected function fSpan($m)
    {
        $tag = $this->span_tags[$m['tag']];
        $atts = $this->parseAttribsToArray($m['atts']);

        if ($m['cite'] != '') {
            $atts['cite'] = trim($m['cite']);
            ksort($atts);
        }

        $atts = $this->formatAttributeString($atts);
        $content = $this->spans($m['content']);
        $opentag = '<'.$tag.$atts.'>';
        $closetag = '';
        $tags = $this->storeTags($opentag, $closetag);
        $out = "{$tags['open']}{$content}{$m['end']}{$tags['close']}";

        if (($m['pre'] && !$m['tail']) || ($m['tail'] && !$m['pre'])) {
            $out = $m['pre'].$out.$m['tail'];
        }

        return $out;
    }

    /**
     * Stores a tag pair in the tag cache.
     *
     * @param  string $opentag  Opening tag
     * @param  string $closetag Closing tag
     * @return array  Reference tokens for both opening and closing tag
     */

    protected function storeTags($opentag, $closetag = '')
    {
        $tags = array();

        $this->refCache[$this->refIndex] = $opentag;
        $tags['open'] = $this->uid.$this->refIndex.':ospan ';
        $this->refIndex++;

        $this->refCache[$this->refIndex] = $closetag;
        $tags['close'] = ' '.$this->uid.$this->refIndex.':cspan';
        $this->refIndex++;

        return $tags;
    }

    /**
     * Replaces reference tokens with corresponding shelved span tags.
     *
     * This method puts all shelved span tags back to the final,
     * parsed input.
     *
     * @param  string $text The input
     * @return string Processed text
     * @see    Parser::storeTags()
     */

    protected function retrieveTags($text)
    {
        $text = preg_replace_callback(
            '/'.$this->uid.'(?P[0-9]+):ospan /',
            array(&$this, 'fRetrieveTags'),
            $text
        );

        $text = preg_replace_callback(
            '/ '.$this->uid.'(?P[0-9]+):cspan/',
            array(&$this, 'fRetrieveTags'),
            $text
        );

        return $text;
    }

    /**
     * Retrieves a tag from the tag cache.
     *
     * @param  array $m Options
     * @return string
     * @see    Parser::retrieveTags()
     */

    protected function fRetrieveTags($m)
    {
        return $this->refCache[$m['token']];
    }

    /**
     * Parses note lists in the given input.
     *
     * This method should be ran after other blocks
     * have been processed, but before reference tokens
     * have been replaced with their replacements.
     *
     * @param  string $text Textile input
     * @return string Processed input
     */

    protected function placeNoteLists($text)
    {
        extract($this->regex_snippets);

        // Sequence all referenced definitions...
        if (!empty($this->notes)) {
            $o = array();
            foreach ($this->notes as $label => $info) {
                if (!empty($info['seq'])) {
                    $o[$info['seq']] = $info;
                    $info['seq'] = $label;
                } else {
                    $this->unreferencedNotes[] = $info;    // Unreferenced definitions go here for possible future use.
                }
            }

            if (!empty($o)) {
                ksort($o);
            }

            $this->notes = $o;
        }

        // Replace list markers.
        $text = preg_replace_callback(
            "@
notelist(?P{$this->c})".
            "(?:\:(?P[$wrd|{$this->syms}]))?".
            "(?P[\^!]?)(?P\+?)\.?$space*
@U$mod",
            array(&$this, "fNoteLists"),
            $text
        );

        return $text;
    }

    /**
     * Formats a note list.
     *
     * @param  array  $m Options
     * @return string Processed note list
     */

    protected function fNoteLists($m)
    {
        if (!$m['startchar']) {
            $m['startchar'] = 'a';
        }

        $index = $m['links'].$m['extras'].$m['startchar'];

        if (empty($this->notelist_cache[$index])) {
            // If not in cache, build the entry...
            $out = array();

            if (!empty($this->notes)) {
                foreach ($this->notes as $seq => $info) {
                    $links = $this->makeBackrefLink($info, $m['links'], $m['startchar']);
                    $atts = '';
                    if (!empty($info['def'])) {
                        $id = $info['id'];
                        extract($info['def']);
                        $out[] = "\t".''.$links.' '.$content.'';
                    } else {
                        $out[] = "\t".''.$links.' Undefined Note [#'.$info['seq'].'].';
                    }
                }
            }

            if ('+' == $m['extras'] && !empty($this->unreferencedNotes)) {
                foreach ($this->unreferencedNotes as $seq => $info) {
                    if (!empty($info['def'])) {
                        extract($info['def']);
                        $out[] = "\t".''.$content.'';
                    }
                }
            }

            $this->notelist_cache[$index] = join("\n", $out);
        }

        if ($this->notelist_cache[$index]) {
            $atts = $this->parseAttribs($m['atts']);
            return "\n{$this->notelist_cache[$index]}\n";
        }

        return '';
    }

    /**
     * Renders a note back reference link.
     *
     * This method renders an array of back reference
     * links for notes.
     *
     * @param  array  $info    Options
     * @param  string $g_links Reference type
     * @param  int    $i       Instance count
     * @return string Processed input
     */

    protected function makeBackrefLink(&$info, $g_links, $i)
    {
        $link    = '';
        $atts    = '';
        $content = '';
        $id      = '';

        if (!empty($info['def'])) {
            extract($info['def']);
        }

        $backlink_type = ($link) ? $link : $g_links;
        $allow_inc = (false === strpos($this->syms, $i));

        $i_ = str_replace(array('&', ';', '#'), '', $this->encodeHigh($i));
        $decode = (strlen($i) !== strlen($i_));

        if ($backlink_type === '!') {
            return '';
        } elseif ($backlink_type === '^') {
            return ''.$i.'';
        } else {
            $out = array();

            foreach ($info['refids'] as $id) {
                $out[] = ''. (($decode) ? $this->decodeHigh($i_) : $i_) .'';
                if ($allow_inc) {
                    $i_++;
                }
            }

            return join(' ', $out);
        }
    }

    /**
     * Formats note definitions.
     *
     * This method formats notes and stores them in
     * note cache for later use and to build reference
     * links.
     *
     * @param  array  $m Options
     * @return string Empty string
     */

    protected function fParseNoteDefs($m)
    {
        $label = $m['label'];
        $link  = $m['link'];
        $att   = $m['att'];
        $content = $m['content'];

        // Assign an id if the note reference parse hasn't found the label yet.
        if (empty($this->notes[$label]['id'])) {
            $this->notes[$label]['id'] = $this->linkPrefix . ($this->linkIndex++);
        }

        // Ignores subsequent defs using the same label
        if (empty($this->notes[$label]['def'])) {
            $this->notes[$label]['def'] = array(
                'atts'    => $this->parseAttribs($att),
                'content' => $this->graf($content),
                'link'    => $link,
            );
        }
        return '';
    }

    /**
     * Parses note references in the given input.
     *
     * This method replaces note reference tags with
     * links.
     *
     * @param  string $text Textile input
     * @return string
     */

    protected function noteRefs($text)
    {
        $text = preg_replace_callback(
            "/\[(?P{$this->c})\#(?P[^\]!]+?)(?P[!]?)\]/Ux",
            array(&$this, "fParseNoteRefs"),
            $text
        );
        return $text;
    }

    /**
     * Formats note reference links.
     *
     * By the time this function is called, all note lists will have been
     * processed into the notes array, and we can resolve the link numbers in
     * the order we process the references.
     *
     * @param  array  $m Options
     * @return string Note reference
     */

    protected function fParseNoteRefs($m)
    {
        $atts = $this->parseAttribs($m['atts']);
        $nolink = ($m['nolink'] === '!');

        // Assign a sequence number to this reference if there isn't one already.

        if (empty($this->notes[$m['label']]['seq'])) {
            $num = $this->notes[$m['label']]['seq'] = ($this->note_index++);
        } else {
            $num = $this->notes[$m['label']]['seq'];
        }

        // Make our anchor point & stash it for possible use in backlinks when the
        // note list is generated later.
        $refid = $this->linkPrefix . ($this->linkIndex++);
        $this->notes[$m['label']]['refids'][] = $refid;

        // If we are referencing a note that hasn't had the definition parsed yet, then assign it an ID.

        if (empty($this->notes[$m['label']]['id'])) {
            $id = $this->notes[$m['label']]['id'] = $this->linkPrefix . ($this->linkIndex++);
        } else {
            $id = $this->notes[$m['label']]['id'];
        }

        // Build the link (if any).
        $out = ''.$num.'';

        if (!$nolink) {
            $out = ''.$out.'';
        }

        // Build the reference.
        return $this->replaceMarkers($this->symbols['nl_ref_pattern'], array('atts' => $atts, 'marker' => $out));
    }

    /**
     * Parses URI into component parts.
     *
     * This method splits a URI-like string apart into component parts, while
     * also providing validation.
     *
     * @param  string $uri The string to pick apart (if possible)
     * @param  array  $m   Reference to an array the URI component parts are assigned to
     * @return bool   TRUE if the string validates as a URI
     * @link   http://tools.ietf.org/html/rfc3986#appendix-B
     */

    protected function parseURI($uri, &$m)
    {
        $r = "@^((?P[^:/?#]+):)?".
            "(//(?P[^/?#]*))?".
            "(?P[^?#]*)".
            "(\?(?P[^#]*))?".
            "(#(?P.*))?@";

        $ok = preg_match($r, $uri, $m);
        return $ok;
    }

    /**
     * Checks whether a component part can be added to a URI.
     *
     * @param  array  $mask  An array of allowed component parts
     * @param  string $name  The component to add
     * @param  array  $parts An array of existing components to modify
     * @return bool   TRUE if the component can be added
     */

    protected function addPart(&$mask, $name, &$parts)
    {
        return (in_array($name, $mask) && isset($parts[$name]) && '' !== $parts[$name]);
    }

    /**
     * Rebuild a URI from parsed parts and a mask.
     *
     * @param  array  $parts  Full array of URI parts
     * @param  string $mask   Comma separated list of URI parts to include in the rebuilt URI
     * @param  bool   $encode Flag to control encoding of the path part of the rebuilt URI
     * @return string         The rebuilt URI
     * @link   http://tools.ietf.org/html/rfc3986#section-5.3
     */

    protected function rebuildURI($parts, $mask = 'scheme,authority,path,query,fragment', $encode = true)
    {
        $mask = explode(',', $mask);
        $out  = '';

        if ($this->addPart($mask, 'scheme', $parts)) {
            $out .= $parts['scheme'] . ':';
        }

        if ($this->addPart($mask, 'authority', $parts)) {
            $out .= '//' . $parts['authority'];
        }

        if ($this->addPart($mask, 'path', $parts)) {
            if (!$encode) {
                $out .= $parts['path'];
            } else {
                $pp = explode('/', $parts['path']);
                foreach ($pp as &$p) {
                    $p = str_replace(array('%25', '%40'), array('%', '@'), rawurlencode($p));
                    if (!in_array($parts['scheme'], array('tel','mailto'))) {
                        $p = str_replace('%2B', '+', $p);
                    }
                }

                $pp = implode('/', $pp);
                $out .= $pp;
            }
        }

        if ($this->addPart($mask, 'query', $parts)) {
            $out .= '?' . $parts['query'];
        }

        if ($this->addPart($mask, 'fragment', $parts)) {
            $out .= '#' . $parts['fragment'];
        }

        return $out;
    }

    /**
     * Parses and shelves links in the given input.
     *
     * This method parses the input Textile document for links.
     * Formats and encodes them, and stores the created link
     * elements in cache.
     *
     * @param  string $text Textile input
     * @return string The input document with link pulled out and replaced with tokens
     */

    protected function links($text)
    {
        $text = $this->markStartOfLinks($text);
        return $this->replaceLinks($text);
    }

    /**
     * Finds and marks the start of well formed links in the input text.
     *
     * @param  string $text String to search for link starting positions
     * @return string Text with links marked
     * @see    Parser::links()
     */

    protected function markStartOfLinks($text)
    {
        // Slice text on '":' boundaries. These always occur in inline
        // links between the link text and the url part and are much more
        // infrequent than '"' characters so we have less possible links
        // to process.
        $mod = $this->regex_snippets['mod'];
        $slices = preg_split('/":(?='.$this->regex_snippets['char'].')/'.$mod, $text);

        if (count($slices) > 1) {

            // There are never any start of links in the last slice, so pop it
            // off (we'll glue it back later).
            $last_slice = array_pop($slices);

            foreach ($slices as &$slice) {

                // If there is no possible start quote then this slice is not a link
                if (false === strpos($slice, '"')) {
                    continue;
                }

                // Cut this slice into possible starting points wherever we
                // find a '"' character. Any of these parts could represent
                // the start of the link text - we have to find which one.
                $possible_start_quotes = explode('"', $slice);

                // Start our search for the start of the link with the closest prior
                // quote mark.
                $possibility = rtrim(array_pop($possible_start_quotes));

                // Init the balanced count. If this is still zero at the end
                // of our do loop we'll mark the " that caused it to balance
                // as the start of the link and move on to the next slice.
                $balanced = 0;
                $linkparts = array();
                $iter = 0;

                while (null !== $possibility) {
                    // Starting at the end, pop off the previous part of the
                    // slice's fragments.

                    // Add this part to those parts that make up the link text.
                    $linkparts[] = $possibility;
                    $len = strlen($possibility) > 0;

                    if ($len) {
                        // did this part inc or dec the balanced count?
                        if (preg_match('/^\S|=$/'.$mod, $possibility)) {
                            $balanced--;
                        }

                        if (preg_match('/\S$/'.$mod, $possibility)) {
                            $balanced++;
                        }

                        $possibility = array_pop($possible_start_quotes);
                    } else {
                        // If quotes occur next to each other, we get zero length strings.
                        // eg. ...""Open the door, HAL!"":url...
                        // In this case we count a zero length in the last position as a
                        // closing quote and others as opening quotes.
                        $balanced = (!$iter++) ? $balanced+1 : $balanced-1;

                        $possibility = array_pop($possible_start_quotes);

                        // If out of possible starting segments we back the last one
                        // from the linkparts array
                        if (null === $possibility) {
                            array_pop($linkparts);
                            break;
                        }

                        // If the next possibility is empty or ends in a space we have a
                        // closing ".
                        if (0 === strlen($possibility) ||
                            preg_match("~{$this->regex_snippets['space']}$~".$mod, $possibility)) {
                            $balanced = 0; // force search exit
                        }
                    }

                    if ($balanced <= 0) {
                        array_push($possible_start_quotes, $possibility);
                        break;
                    }

                }

                // Rebuild the link's text by reversing the parts and sticking them back
                // together with quotes.
                $link_content = implode('"', array_reverse($linkparts));

                // Rebuild the remaining stuff that goes before the link but that's
                // already in order.
                $pre_link = implode('"', $possible_start_quotes);

                // Re-assemble the link starts with a specific marker for the next regex.
                $slice = $pre_link . $this->uid.'linkStartMarker:"' . $link_content;
            }

            // Add the last part back
            $slices[] = $last_slice;
        }

        // Re-assemble the full text with the start and end markers
        $text = implode('":', $slices);

        return $text;
    }

    /**
     * Replaces links with tokens and stores them on the shelf.
     *
     * @param  string $text The input
     * @return string Processed input
     * @see    Parser::links()
     */

    protected function replaceLinks($text)
    {
        $stopchars = "\s|^'\"*";

        return preg_replace_callback(
            '/
            (?P
\[)?                    # Optionally open with a square bracket eg. Look ["here":url]
            '.$this->uid.'linkStartMarker:" # marks start of the link
            (?P.*?)                  # grab the content of the inner "..." part of the link, can be anything but
                                            # do not worry about matching class, id, lang or title yet
            ":                              # literal ": marks end of atts + text + title block
            (?P[^'.$stopchars.']*)    # url upto a stopchar
            /x'.$this->regex_snippets['mod'],
            array(&$this, "fLink"),
            $text
        );
    }

    /**
     * Formats a link and stores it on the shelf.
     *
     * @param  array  $m Options
     * @return string Reference token for the shelved content
     * @see    Parser::replaceLinks()
     */

    protected function fLink($m)
    {
        $in    = $m[0];
        $pre   = $m['pre'];
        $inner = $m['inner'];
        $url   = $m['urlx'];
        $m = array();

        // Treat empty inner part as an invalid link.
        $trimmed = trim($inner);
        if (empty($trimmed)) {
            return $pre.'"'.$inner.'":'.$url;
        }

        // Split inner into $atts, $text and $title..
        preg_match(
            '/
            ^
            (?P' . $this->cls . ')            # $atts (if any)
            ' . $this->regex_snippets['space'] . '* # any optional spaces
            (?P                               # $text is...
                (!.+!)                              #     an image
            |                                       #   else...
                .+?                                 #     link text
            )                                       # end of $text
            (?:\((?P