Release 2.4.13

Fix missing new/rename buttons

.gitattributes

@@ -0,0 +1,32 @@
+# https://help.github.com/articles/dealing-with-line-endings
+#
+# For Mac & Linux
+# git config --global core.autocrlf input
+#
+# For windows
+# git config --global core.autocrlf true
+#
+# Set default behaviour, in case users don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files we want to always be normalized and converted 
+# to native line endings on checkout.
+*.txt text
+*.md text
+*.rb text
+*.js text
+*.html text
+*.yml text
+*.mustache text
+*.css text
+Rakefile text
+Gemfile text
+LICENSE text
+COPYRIGHT text
+gollum text
+.gitattributes text
+.gitignore text
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary

.gitignore

@@ -1,3 +1,7 @@
 coverage
 pkg
 .DS_Store
+.bundle
+Gemfile.lock
+*.gem
+*.swp

.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+notifications:
+  email:
+    - code@bootstraponline.com
+before_install:
+ - sudo apt-get update

Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'rake', '~> 10.0.3'

HISTORY.md

@@ -1,3 +1,106 @@
+# 2.4.11 / 2013-01-08
+
+* Numerous security issues have been fixed. Please update to `2.4.11`
+
+# 1.4.0 / 2012-04-10
+
+* Minor
+  * Add a way to configure the `#id_prefix` property of Sanitization
+    objects.
+  * Add web sequence diagrams support
+  * Support for updating wysiwyg components when markup language changes
+  * Support RedCarpet 2.0
+  * Allow ftp and irc links in wiki markup
+  * Minor ui fixups
+
+* Bug Fixes
+  * Include the language of the code snippet when making a uniquely
+    identifiable sha of a code snippet while rendering a page.
+  * Pygments lexer forces utf8 encoding
+  * Remove MathJax, this created problems in production for us.
+    We'll look at bringing it back in future releases
+
+# 1.3.1 / 2011-07-21
+
+* Major Enhancements
+  * Allow prefixed ID attributes in headers to support internal linking
+    (#146).
+  * Markdown pages are rendered through Redcarpet by default (#176).
+* Minor Enhancements
+  * Remove Edit button on Preview pages (#164).
+  * Simplify Wiki#inspect and Page#inspect.
+* Bug Fixes
+  * Fixed broken preview functionality (#157).
+  * Fixed sidebar/footer rendering problems related to whitespace (#145).
+
+# 1.3.0 / 2011-04-25
+
+* Major Enhancements
+  * Listing of all Pages
+  * Support for running Gollum under a separate branch.
+* Minor Enhancements
+  * Fix a security issue with rendering Mathjax.
+
+# 1.2.0 / 2011-03-11
+
+* Major Enhancements
+  * Major HTML/CSS/JS overhaul.
+  * Add Sidebars (similar to Footers).
+  * Add commit reverts.
+* Minor Enhancements
+  * Optimization in source code highlighting, resulting in a huge
+    decrease in rendering time.
+  * Security fixes related to source code highlighting.
+
+* Major Enhancements
+  * Add Page sidebars, similar to Page footers.
+  * Add the ability to revert commits to the wiki.
+  * Add MediaWiki support.
+* Minor Enhancements
+  * Add `:sanitization` and `:history_sanitization` options for customizing
+    how `Sanitize.clean` modifies formatted wiki content.
+  * Add `--config` option for the command line, to specify a ruby file that is
+    run during startup.
+  * Provide access to a parsed Nokogiri::DocumentFragment during markup
+    rendering for added customization.
+* Bug Fixes
+  * Use `@wiki.page_class` in Gollum::Markup where appropriate (#63).
+  * Fix parsing of Org mode file links (#87).
+
+# 1.1.0 / 2010-10-28
+
+* Major Enhancements
+  * Optimize page write/update/delete to use Grit::Index::read_tree instead
+    of manually recreating entire index contents.
+  * Added --irb option for the gollum command.
+  * Update working dir (if present) when edited via the API (#6)
+  * Add basic `git grep` based search for repos.
+* Minor Enhancements
+  * Support a `:gollum_path` Sinatra setting for `Precious::App`
+  * Add Wiki#size to efficiently count pages without loading them.
+  * Add the correct content type when serving files from the frontend.
+  * Add --host option and default it to 127.0.0.1.
+  * Allow anchors in page links, such as `[[Abc#header]]`.
+  * All pages retrieved with a SHA add `rel="nofollow"` to all
+    page links.
+* Bug Fixes
+  * Increase minimum Sanitize version requirement to 1.1.0.
+    1.0.x versions of Sanitize require Hpricot instead of Nokogiri
+    and have bugs that may allow non-whitelisted HTML to sneak
+    through.
+  * Introduce Ruby 1.9 compatibility fixes.
+  * Commit hashes are normalized so that missing author data is replaced with
+    anonymous info.
+  * Prevent `Gollum::Wiki#write_page` from clobbering existing pages.
+  * Handle duplicate page errors in frontend.
+  * Fix bugs trying to retrieve pages with invalid names.
+  * CGI escape page names in links and redirects.
+
+# 1.0.1 / 2010-08-12
+
+* Bug Fixes
+  * Force Grit dep to 2.1 or higher.
+
 # 1.0.0 / 2010-08-12
 
-* Open Source Birthday!
+* Open Source Birthday!

Home.md

@@ -0,0 +1,3 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque vulputate tincidunt sollicitudin. Quisque sit amet leo sed nunc eleifend rhoncus in consectetur leo. Vivamus posuere semper convallis. Duis malesuada lacus sed erat lobortis tincidunt mattis ligula consectetur. Sed aliquam vulputate eros at euismod. Aenean egestas lorem ligula, quis faucibus turpis. Curabitur a eros in ipsum gravida ornare. Sed elementum enim vel mi scelerisque dapibus. Nulla id libero ligula, quis tempus sem. Morbi nec felis tortor, ac cursus risus. Mauris elementum tortor id lacus eleifend non lobortis tellus pharetra. Etiam posuere cursus vestibulum.  $x \lt y$ 
+
+Morbi tincidunt dolor vel massa dictum volutpat. Vestibulum quis nibh metus, id tincidunt nisl. Vivamus eget sem ac risus eleifend rhoncus at eu nisl. Nunc elit massa, vulputate ac gravida eget, condimentum quis justo. Integer scelerisque, libero vel consequat ultricies, eros libero sagittis libero, pellentesque bibendum quam massa ut orci. Maecenas sit amet urna eget quam aliquam posuere. Nulla facilisi. Duis imperdiet augue sit amet metus ornare et hendrerit dui feugiat. Aenean a lacus neque. Sed eu enim tincidunt dolor pharetra porttitor. Vestibulum ut felis dui, rutrum iaculis orci. Duis eu bibendum tortor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Suspendisse mollis sagittis purus sit amet sollicitudin. Phasellus vel interdum erat. 

README.md

@@ -1,6 +1,9 @@
 gollum -- A wiki built on top of Git
 ====================================
 
+[![Build Status](https://secure.travis-ci.org/gollum/gollum.png?branch=master)](http://travis-ci.org/gollum/gollum)
+[![Dependency Status](https://gemnasium.com/gollum/gollum.png)](https://gemnasium.com/gollum/gollum)
+
 ## DESCRIPTION
 
 Gollum is a simple wiki system built on top of Git that powers GitHub Wikis.
@@ -9,33 +12,56 @@ Gollum wikis are simply Git repositories that adhere to a specific format.
 Gollum pages may be written in a variety of formats and can be edited in a
 number of ways depending on your needs. You can edit your wiki locally:
 
-* With your favorite text editor or IDE.
+* With your favorite text editor or IDE (changes will be visible after committing).
 * With the built-in web interface.
 * With the Gollum Ruby API.
 
 Gollum follows the rules of [Semantic Versioning](http://semver.org/) and uses
 [TomDoc](http://tomdoc.org/) for inline documentation.
 
+## SYSTEM REQUIREMENTS
+
+- Python 2.5+ (2.7.3 recommended)
+- Ruby 1.8.7+ (1.9.3 recommended)
+- Unix like operating system (OS X, Ubuntu, Debian, and more)
+- Will not work on Windows (because of [grit](https://github.com/github/grit))
+
+## SECURITY
+
+Don't enable `--custom-css` or `--custom-js` unless you trust every user who has the ability to edit the wiki.
+A better solution with more security is being tracked in [#665](https://github.com/gollum/gollum/issues/665).
 
 ## INSTALLATION
 
 The best way to install Gollum is with RubyGems:
 
-    $ [sudo] gem install gollum
+```bash
+$ [sudo] gem install gollum
+```
+
+If you're installing from source, you can use [Bundler][bundler] to pick up all the
+gems:
+
+```bash
+$ bundle install
+```
 
 In order to use the various formats that Gollum supports, you will need to
 separately install the necessary dependencies for each format. You only need
 to install the dependencies for the formats that you plan to use.
 
-* [ASCIIDoc](http://www.methods.co.nz/asciidoc/) -- `brew install asciidoc`
+* [ASCIIDoc](http://www.methods.co.nz/asciidoc/) -- `brew install asciidoc` on mac or `apt-get install -y asciidoc` on Ubuntu
 * [Creole](http://wikicreole.org/) -- `gem install creole`
-* [Markdown](http://daringfireball.net/projects/markdown/) -- `gem install rdiscount`
+* [Markdown](http://daringfireball.net/projects/markdown/) -- `gem install redcarpet`
+* [GitHub Flavored Markdown](https://help.github.com/articles/github-flavored-markdown) -- `gem install github-markdown`
 * [Org](http://orgmode.org/) -- `gem install org-ruby`
 * [Pod](http://search.cpan.org/dist/perl/pod/perlpod.pod) -- `Pod::Simple::HTML` comes with Perl >= 5.10. Lower versions should install Pod::Simple from CPAN.
 * [RDoc](http://rdoc.sourceforge.net/)
 * [ReStructuredText](http://docutils.sourceforge.net/rst.html) -- `easy_install docutils`
 * [Textile](http://www.textism.com/tools/textile/) -- `gem install RedCloth`
+* [MediaWiki](http://www.mediawiki.org/wiki/Help:Formatting) -- `gem install wikicloth`
 
+[bundler]: http://gembundler.com/
 
 ## RUNNING
 
@@ -43,14 +69,19 @@ To view and edit your Gollum repository locally via the built in web
 interface, simply install the Gollum gem, navigate to your repository via the
 command line, and run the executable:
 
-    $ gollum
+```bash
+$ gollum
+```
 
 This will start up a web server running the Gollum frontend and you can view
 and edit your wiki at http://localhost:4567. To get help on the command line
 utility, you can run it like so:
 
-    $ gollum --help
+```bash
+$ gollum --help
+```
 
+Note that the gollum server will not run on Windows because of [an issue](https://github.com/rtomayko/posix-spawn/issues/9) with posix-spawn (which is used by Grit).
 
 ## REPO STRUCTURE
 
@@ -59,12 +90,11 @@ is written in `page files` and may be organized into directories any way you
 choose. Special footers can be created in `footer files`. Other content
 (images, PDFs, etc) may also be present and organized in the same way.
 
-
 ## PAGE FILES
 
 Page files may be written in any format supported by
-[GitHub-Markup](http://github.com/defunkt/github-markup) (except roff). The
-current list of formats and allowed extensions is:
+[GitHub-Markup](http://github.com/github/markup) (except roff). By default,
+Gollum recognizes the following extensions:
 
 * ASCIIDoc: .asciidoc
 * Creole: .creole
@@ -74,9 +104,18 @@ current list of formats and allowed extensions is:
 * RDoc: .rdoc
 * ReStructuredText: .rest.txt, .rst.txt, .rest, .rst
 * Textile: .textile
+* MediaWiki: .mediawiki, .wiki
+
+You may also register your own extensions and parsers:
+
+```ruby
+Gollum::Markup.register(:angry, "Angry") do |content|
+  content.upcase
+end
+```
 
 Gollum detects the page file format via the extension, so files must have one
-of the supported extensions in order to be converted.
+of the default or registered extensions in order to be converted.
 
 Page file names may contain any printable UTF-8 character except space
 (U+0020) and forward slash (U+002F). If you commit a page file with any of
@@ -90,14 +129,26 @@ The special page file `Home.ext` (where the extension is one of the supported
 formats) will be used as the entrance page to your wiki. If it is missing, an
 automatically generated table of contents will be shown instead.
 
+## SIDEBAR FILES
+
+Sidebar files allow you to add a simple sidebar to your wiki. Sidebar files
+are named `_Sidebar.ext` where the extension is one of the supported formats.
+Sidebars affect all pages in their directory and any subdirectories that do not
+have a sidebar file of their own.
+
+## HEADER FILES
+
+Header files allow you to add a simple header to your wiki. Header files must
+be named `_Header.ext` where the extension is one of the supported formats.
+Like sidebars, headers affect all pages in their directory and any
+subdirectories that do not have a header file of their own.
 
 ## FOOTER FILES
 
 Footer files allow you to add a simple footer to your wiki. Footer files must
 be named `_Footer.ext` where the extension is one of the supported formats.
-Footers affect all pages in their directory and any subdirectories that do not
-have a footer file of their own.
-
+Like sidebars, footers affect all pages in their directory and any
+subdirectories that do not have a footer file of their own.
 
 ## HTML SANITIZATION
 
@@ -106,6 +157,15 @@ or JavaScript. These tags will be stripped from the converted HTML. See
 `docs/sanitization.md` for more details on what tags and attributes are
 allowed.
 
+## TITLES
+
+The first defined `h1` will override the default header on a page. There are
+two ways to set a page title. The metadata syntax:
+
+    <!-- --- title: New Title -->
+
+The first `h1` tag can be set to always override the page title, without
+needing to use the metadata syntax. Start gollum with the `--h1-title` flag.
 
 ## BRACKET TAGS
 
@@ -124,6 +184,9 @@ the link text displayed on the page. If the tag is an embedded image, the
 first thing in the tag will be a path to an image file. Use this trick to
 easily remember which order things should appear in tags.
 
+Some formats, such as MediaWiki, support the opposite syntax:
+
+    [[Page Title|Link]]
 
 ## PAGE LINKS
 
@@ -135,8 +198,8 @@ The above tag will create a link to the corresponding page file named
 `Frodo-Baggins.ext` where `ext` may be any of the allowed extension types. The
 conversion is as follows:
 
-  1. Replace any spaces (U+0020) with dashes (U+002D)
-  2. Replace any slashes (U+002F) with dashes (U+002D)
+1. Replace any spaces (U+0020) with dashes (U+002D)
+2. Replace any slashes (U+002F) with dashes (U+002D)
 
 If you'd like the link text to be something that doesn't map directly to the
 page name, you can specify the actual page name after a pipe:
@@ -210,7 +273,7 @@ the pipe.
 ## IMAGES
 
 To display images that are contained in the Gollum repository you should use
-the Gollum Image Tag. This will display the actual image on the page. 
+the Gollum Image Tag. This will display the actual image on the page.
 
     [[gollum.png]]
 
@@ -239,6 +302,12 @@ specified, default alignment is `left`.
 
     [[gollum.png|float]]
 
+By default text will fill up all the space around the image. To control how
+much should show up use this tag to stop and start a new block so that
+additional content doesn't fill in.
+
+    [[_]]
+
 To specify a max-width, use the `width=` option. Units must be specified in
 either `px` or `em`.
 
@@ -264,12 +333,30 @@ wiki page, simply preface the link with a single quote (like in LISP):
 
 This is useful for writing about the link syntax in your wiki pages.
 
+## TABLE OF CONTENTS
+
+Gollum has a special tag to insert a table of contents (new in v2.1)
+
+    [[_TOC_]]
+
+This tag is case sensitive, use all upper case.  The TOC tag can be inserted
+into the `_Header`, `_Footer` or `_Sidebar` files too.
+
+There is also a wiki option `:universal_toc` which will display a
+table of contents at the top of all your wiki pages if it is enabled.
+The `:universal_toc` is not enabled by default.  To set the option,
+add the option to the `:wiki_options` hash before starting the
+frontend app:
+
+```ruby
+Precious::App.set(:wiki_options, {:universal_toc => true})
+```
 
 ## SYNTAX HIGHLIGHTING
 
 In page files you can get automatic syntax highlighting for a wide range of
-languages (courtesy of [Pygments](http://pygments.org/)) by using the
-following syntax:
+languages (courtesy of [Pygments](http://pygments.org/) - must install
+separately) by using the following syntax:
 
     ```ruby
       def foo
@@ -277,149 +364,258 @@ following syntax:
       end
     ```
 
-The block must start with three backticks (as the first characters on the
-line). After that comes the name of the language that is contained by the
+The block must start with three backticks, at the beginning of a line or
+indented with any number of spaces or tabs.
+After that comes the name of the language that is contained by the
 block. The language must be one of the `short name` lexer strings supported by
 Pygments. See the [list of lexers](http://pygments.org/docs/lexers/) for valid
 options.
 
-If the block contents are indented two spaces or one tab, then that whitespace
-will be ignored (this makes the blocks easier to read in plaintext).
+The block contents should be indented at the same level than the opening backticks.
+If the block contents are indented with an additional two spaces or one tab,
+then that whitespace will be ignored (this makes the blocks easier to read in plaintext).
 
-The block must end with three backticks as the first characters on a
-line.
+The block must end with three backticks indented at the same level than the opening
+backticks.
 
+### GITHUB SYNTAX HIGHLIGHTING
+
+As an extra feature, you can syntax highlight a file from your repository, allowing
+you keep some of your sample code in the main repository. The code-snippet is
+updated when the wiki is rebuilt. You include github code like this:
+
+    ```html:github:gollum/gollum/master/test/file_view/1_file.txt```
+
+This will make the builder look at the **gollum user**, in the **gollum project**,
+in the **master branch**, at path **test/file_view/1_file.txt**. It will be
+rewritten to:
+
+    ```html
+    <ol class="tree">
+      <li class="file"><a href="0">0</a></li>
+    </ol>
+    ```
+
+Which will be parsed as HTML code during the Pygments run, and thereby coloured
+appropriately.
 
 ## MATHEMATICAL EQUATIONS
 
-Page files may contain mathematic equations in TeX syntax that will be nicely
-typeset into the expected output. A block-style equation is delimited by `\[`
-and `\]`. For example:
+Start gollum with the `--mathjax` flag. Read more about [MathJax](http://docs.mathjax.org/en/latest/index.html) on the web. Gollum uses the `TeX-AMS-MML_HTMLorMML` config with the `autoload-all` extension.
 
-    \[ P(E) = {n \choose k} p^k (1-p)^{ n-k} \]
+Inline math:
 
-Inline equations are delimited by `\(` and `\)`. These equations will appear
-inline with regular text. For example:
+- \\(2^2\\)
 
-    The Pythagorean theorum is \( a^2 + b^2 = c^2 \).
+Display math:
 
-Gollum uses [MathJax](http://www.mathjax.org/) to convert the TeX syntax into
-output suitable for display in web browsers.
+- $$2^2$$
+- \\[2^2\\]
 
+## SEQUENCE DIAGRAMS
+
+You may imbed sequence diagrams into your wiki page (rendered by
+[WebSequenceDiagrams](http://www.websequencediagrams.com) by using the
+following syntax:
+
+    {{{{{{ blue-modern
+      alice->bob: Test
+      bob->alice: Test response
+    }}}}}}
+
+You can replace the string "blue-modern" with any supported style.
 
 ## API DOCUMENTATION
 
-The Gollum API allows you to retrieve raw or formatted wiki content from a Git
-repository, write new content to the repository, and collect various meta data
-about the wiki as a whole.
+The [Gollum API](https://github.com/gollum/gollum-lib/) allows you to retrieve
+raw or formatted wiki content from a Git repository, write new content to the
+repository, and collect various meta data about the wiki as a whole.
 
-Initialize the Gollum::Repo object:
+Initialize the `Gollum::Repo` object:
 
-    # Require rubygems if necessary
-    require 'rubygems'
+```ruby
+# Require rubygems if necessary
+require 'rubygems'
 
-    # Require the Gollum library
-    require 'gollum'
+# Require the Gollum library
+require 'gollum-lib'
 
-    # Create a new Gollum::Wiki object by initializing it with the path to the
-    # Git repository.
-    wiki = Gollum::Wiki.new("my-gollum-repo.git")
-    # => <Gollum::Wiki>
+# Create a new Gollum::Wiki object by initializing it with the path to the
+# Git repository.
+wiki = Gollum::Wiki.new("my-gollum-repo.git")
+# => <Gollum::Wiki>
+```
 
-By default, internal wiki links are all absolute from the root. To specify a different base path, you can send specify the `:base_path` option:
+By default, internal wiki links are all absolute from the root. To specify a different
+base path, you can specify the `:base_path` option:
 
-    wiki = Gollum::Wiki.new("my-gollum-repo.git", :base_path => "/wiki")
+```ruby
+wiki = Gollum::Wiki.new("my-gollum-repo.git", :base_path => "/wiki")
+```
+
+Note that base_path just modifies the links. To map gollum to a non-root location:
+
+- Use the gollum binary: `gollum path/to/wiki --base-path mywiki`
+- Define config.ru with `map`. See [#532](https://github.com/gollum/gollum/issues/532) for an example.
+
+> :base_path     - String base path for all Wiki links.
+>
+> The String base path to prefix to internal links. For example, when set
+> to "/wiki", the page "Hobbit" will be linked as "/wiki/Hobbit". Defaults
+> to "/".
 
 Get the latest version of the given human or canonical page name:
 
-    page = wiki.page('page-name')
-    # => <Gollum::Page>
+```ruby
+page = wiki.page('page-name')
+# => <Gollum::Page>
 
-    page.raw_data
-    # => "# My wiki page"
+page.raw_data
+# => "# My wiki page"
 
-    page.formatted_data
-    # => "<h1>My wiki page</h1>"
+page.formatted_data
+# => "<h1>My wiki page</h1>"
 
-    page.format
-    # => :markdown
+page.format
+# => :markdown
 
-    vsn = page.version
-    # => <Grit::Commit>
+vsn = page.version
+# => <Grit::Commit>
 
-    vsn.id
-    # => '3ca43e12377ea1e32ea5c9ce5992ec8bf266e3e5'
+vsn.id
+# => '3ca43e12377ea1e32ea5c9ce5992ec8bf266e3e5'
+```
 
 Get the footer (if any) for a given page:
 
-    page.footer
-    # => <Gollum::Page>
+```ruby
+page.footer
+# => <Gollum::Page>
+```
+
+Get the header (if any) for a given page:
+
+```ruby
+page.header
+# => <Gollum::Page>
+```
 
 Get a list of versions for a given page:
 
-    vsns = wiki.page('page-name').versions
-    # => [<Grit::Commit, <Grit::Commit, <Grit::Commit>]
+```ruby
+vsns = wiki.page('page-name').versions
+# => [<Grit::Commit, <Grit::Commit, <Grit::Commit>]
 
-    vsns.first.id
-    # => '3ca43e12377ea1e32ea5c9ce5992ec8bf266e3e5'
+vsns.first.id
+# => '3ca43e12377ea1e32ea5c9ce5992ec8bf266e3e5'
 
-    vsns.first.authored_date
-    # => Sun Mar 28 19:11:21 -0700 2010
+vsns.first.authored_date
+# => Sun Mar 28 19:11:21 -0700 2010
+```
 
 Get a specific version of a given canonical page file:
 
-    wiki.page('page-name', '5ec521178e0eec4dc39741a8978a2ba6616d0f0a')
+```ruby
+wiki.page('page-name', '5ec521178e0eec4dc39741a8978a2ba6616d0f0a')
+```
 
 Get the latest version of a given static file:
 
-    file = wiki.file('asset.js')
-    # => <Gollum::File>
+```ruby
+file = wiki.file('asset.js')
+# => <Gollum::File>
 
-    file.raw_data
-    # => "alert('hello');"
+file.raw_data
+# => "alert('hello');"
 
-    file.version
-    # => <Grit::Commit>
+file.version
+# => <Grit::Commit>
+```
 
 Get a specific version of a given static file:
 
-    wiki.file('asset.js', '5ec521178e0eec4dc39741a8978a2ba6616d0f0a')
+```ruby
+wiki.file('asset.js', '5ec521178e0eec4dc39741a8978a2ba6616d0f0a')
+```
 
 Get an in-memory Page preview (useful for generating previews for web
 interfaces):
 
-    preview = wiki.preview_page("My Page", "# Contents", :markdown)
-    preview.formatted_data
-    # => "<h1>Contents</h1>"
+```ruby
+preview = wiki.preview_page("My Page", "# Contents", :markdown)
+preview.formatted_data
+# => "<h1>Contents</h1>"
+```
 
 Methods that write to the repository require a Hash of commit data that takes
 the following form:
 
-    commit = { :message => 'commit message',
-               :name => 'Tom Preston-Werner',
-               :email => 'tom@github.com' }
+```ruby
+commit = { :message => 'commit message',
+           :name => 'Tom Preston-Werner',
+           :email => 'tom@github.com' }
+```
 
 Write a new version of a page (the file will be created if it does not already
 exist) and commit the change. The file will be written at the repo root.
 
-    wiki.write_page('Page Name', :markdown, 'Page contents', commit)
+```ruby
+wiki.write_page('Page Name', :markdown, 'Page contents', commit)
+```
 
 Update an existing page. If the format is different than the page's current
 format, the file name will be changed to reflect the new format.
 
-    page = wiki.page('Page Name')
-    wiki.update_page(page, page.name, page.format, 'Page contents', commit)
+```ruby
+page = wiki.page('Page Name')
+wiki.update_page(page, page.name, page.format, 'Page contents', commit)
+```
 
 To delete a page and commit the change:
 
-    wiki.delete_page(page, commit)
+```ruby
+wiki.delete_page(page, commit)
+```
 
+### RACK
+
+You can also run gollum with any rack-compatible server by placing this config.ru
+file inside your wiki repository. This allows you to utilize any Rack middleware
+like Rack::Auth, OmniAuth, etc.
+
+```ruby
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'gollum/app'
+
+gollum_path = File.expand_path(File.dirname(__FILE__)) # CHANGE THIS TO POINT TO YOUR OWN WIKI REPO
+Precious::App.set(:gollum_path, gollum_path)
+Precious::App.set(:default_markup, :markdown) # set your favorite markup language
+Precious::App.set(:wiki_options, {:universal_toc => false})
+run Precious::App
+```
+
+Your Rack middleware can pass author details to Gollum in a Hash in the session under the 'gollum.author' key.
+
+## WINDOWS FILENAME VALIDATION
+
+Note that filenames on windows must not contain any of the following characters `\ / : * ? " < > |`. See [this support article](http://support.microsoft.com/kb/177506) for details.
+
+## CONFIG FILE
+
+Gollum optionally takes a `--config file`. See [config.rb](https://github.com/gollum/gollum/blob/master/config.rb) for an example.
+
+## CUSTOM CSS/JS
+
+The `--css` flag will inject `custom.css` from the root of your git repository into each page. `custom.css` must be commited to git or you will get a 302 redirect to the create page.
+
+The `--js` flag will inject `custom.js` from the root of your git repository into each page. `custom.js` must be commited to git or you will get a 302 redirect to the create page.
 
 ## CONTRIBUTE
 
-If you'd like to hack on Gollum, start by forking my repo on GitHub:
+If you'd like to hack on Gollum, start by forking the repo on GitHub:
 
-http://github.com/github/gollum
+http://github.com/gollum/gollum
 
 To get all of the dependencies, install the gem first. The best way to get
 your changes merged back into core is as follows:
@@ -432,4 +628,57 @@ your changes merged back into core is as follows:
 1. Do not change the version number, I will do that on my end
 1. If necessary, rebase your commits into logical chunks, without errors
 1. Push the branch up to GitHub
-1. Send me (mojombo) a pull request for your branch
+1. Send a pull request to the gollum/gollum project.
+
+## RELEASING
+
+Gollum uses [Semantic Versioning](http://semver.org/).
+
+    x.y.z
+
+For z releases:
+
+```bash
+$ rake bump
+$ rake release
+```
+
+For x.y releases:
+
+```bash
+Update VERSION in lib/gollum.rb
+$ rake gemspec
+$ rake release
+```
+
+## BUILDING THE GEM FROM MASTER
+
+```bash
+$ gem uninstall -aIx gollum
+$ git clone https://github.com/gollum/gollum.git
+$ cd gollum
+gollum$ rake build
+gollum$ gem install --no-ri --no-rdoc pkg/gollum*.gem
+```
+
+## RUN THE TESTS
+
+```bash
+$ bundle install
+$ bundle exec rake test
+```
+
+## WORK WITH TEST REPOS
+
+An example of how to add a test file to the bare repository lotr.git.
+
+```bash
+$ mkdir tmp; cd tmp
+$ git clone ../lotr.git/ .
+Cloning into '.'...
+done.
+$ git log
+$ echo "test" > test.md
+$ git add . ; git commit -am "Add test"
+$ git push ../lotr.git/ master
+```

Rakefile

@@ -17,6 +17,27 @@ def version
   line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
 end
 
+# assumes x.y.z all digit version
+def next_version
+  # x.y.z
+  v = version.split '.'
+  # bump z
+  v[-1] = v[-1].to_i + 1
+  v.join '.'
+end
+
+def bump_version
+  old_file = File.read("lib/#{name}.rb")
+  old_version_line = old_file[/^\s*VERSION\s*=\s*.*/]
+  new_version = next_version
+  # replace first match of old vesion with new version
+  old_file.sub!(old_version_line, "  VERSION = '#{new_version}'")
+
+  File.write("lib/#{name}.rb", old_file)
+
+  new_version
+end
+
 def date
   Date.today.to_s
 end
@@ -47,7 +68,7 @@ task :default => :test
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
+  test.libs << 'lib' << 'test' << '.'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
@@ -60,14 +81,6 @@ task :coverage do
   sh "open coverage/index.html"
 end
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "#{name} #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 desc "Open an irb session preloaded with this library"
 task :console do
   sh "irb -rubygems -r ./lib/#{name}.rb"
@@ -79,7 +92,14 @@ end
 #
 #############################################################################
 
-
+desc "Update version number and gemspec"
+task :bump do
+  puts "Updated version to #{bump_version}"
+  # Execute does not invoke dependencies.
+  # Manually invoke gemspec then validate.
+  Rake::Task[:gemspec].execute
+  Rake::Task[:validate].execute
+end
 
 #############################################################################
 #
@@ -87,24 +107,28 @@ end
 #
 #############################################################################
 
+desc 'Create a release build'
 task :release => :build do
   unless `git branch` =~ /^\* master$/
     puts "You must be on the master branch to release!"
     exit!
   end
   sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git pull"
   sh "git tag v#{version}"
   sh "git push origin master"
-  sh "git push v#{version}"
+  sh "git push origin v#{version}"
   sh "gem push pkg/#{name}-#{version}.gem"
 end
 
+desc 'Build gem'
 task :build => :gemspec do
   sh "mkdir -p pkg"
   sh "gem build #{gemspec_file}"
   sh "mv #{gem_file} pkg"
 end
 
+desc 'Update gemspec'
 task :gemspec => :validate do
   # read spec file and split out manifest section
   spec = File.read(gemspec_file)
@@ -122,7 +146,7 @@ task :gemspec => :validate do
     split("\n").
     sort.
     reject { |file| file =~ /^\./ }.
-    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    reject { |file| file =~ /^(rdoc|pkg|test|Home\.md|\.gitattributes)/ }.
     map { |file| "    #{file}" }.
     join("\n")
 
@@ -133,6 +157,7 @@ task :gemspec => :validate do
   puts "Updated #{gemspec_file}"
 end
 
+desc 'Validate lib files and version file'
 task :validate do
   libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
   unless libfiles.empty?
@@ -143,4 +168,4 @@ task :validate do
     puts "A `VERSION` file at root level violates Gem best practices."
     exit!
   end
-end
+end

bin/gollum

@@ -8,18 +8,19 @@ Gollum is a multi-format Wiki Engine/API/Frontend.
 Basic Command Line Usage:
   gollum [OPTIONS] [PATH]
 
-        PATH                         The path to the Gollum repository.
+        PATH                         The path to the Gollum repository (default .).
 
 Options:
 HELP
 
 require 'optparse'
-
 require 'rubygems'
-require 'gollum/frontend/app'
+require 'gollum'
 
 exec = {}
-options = {}
+options = { 'port' => 4567, 'bind' => '0.0.0.0' }
+wiki_options = {}
+
 opts = OptionParser.new do |opts|
   opts.banner = help
 
@@ -27,15 +28,168 @@ opts = OptionParser.new do |opts|
     options['port'] = port.to_i
   end
 
+  opts.on("--host [HOST]", "Hostname or IP address to listen on (default 0.0.0.0).") do |host|
+    options['bind'] = host
+  end
+
   opts.on("--version", "Display current version.") do
     puts "Gollum " + Gollum::VERSION
     exit 0
   end
+
+  opts.on("--config [CONFIG]", "Path to additional configuration file") do |config|
+    options['config'] = config
+  end
+
+  opts.on("--irb", "Start an irb process with gollum loaded for the current wiki.") do
+    options['irb'] = true
+  end
+
+  opts.on("--css", "Inject custom css. Uses custom.css from root repository") do
+    wiki_options[:css] = true
+  end
+
+  opts.on("--js", "Inject custom js. Uses custom.js from root repository") do
+    wiki_options[:js] = true
+  end
+
+  opts.on("--page-file-dir [PATH]", "Specify the sub directory for all page files (default: repository root).") do |path|
+    wiki_options[:page_file_dir] = path
+  end
+
+  opts.on("--base-path [PATH]", "Specify the base path.") do |path|
+    wiki_options[:base_path] = path
+  end
+
+  opts.on("--gollum-path [PATH]", "Specify the gollum path.") do |path|
+    wiki_options[:gollum_path] = path
+  end
+
+  opts.on("--ref [REF]", "Specify the repository ref to use (default: master).") do |ref|
+    wiki_options[:ref] = ref
+  end
+
+  opts.on("--no-live-preview", "Disables livepreview.") do
+    wiki_options[:live_preview] = false
+  end
+
+  opts.on("--mathjax", "Enables mathjax.") do
+    wiki_options[:mathjax] = true
+  end
+
+  opts.on("--user-icons [SOURCE]", "Set the history user icons. Valid values: gravatar, identicon, none. Default: none.") do |source|
+    wiki_options[:user_icons] = source
+  end
+
+  opts.on("--show-all", "Shows all files in file view. By default only valid pages are shown.") do
+    wiki_options[:show_all] = true
+  end
+
+  opts.on("--collapse-tree", "Collapse file view tree. By default, expanded tree is shown.") do
+    wiki_options[:collapse_tree] = true
+  end
+  opts.on("--h1-title", "Sets page title to value of first h1") do
+    wiki_options[:h1_title] = true
+  end
 end
 
 # Read command line options into `options` hash
-opts.parse!
+begin
+  opts.parse!
+rescue OptionParser::InvalidOption
+  puts "gollum: #{$!.message}"
+  puts "gollum: try 'gollum --help' for more information"
+  exit
+end
 
-$path = ARGV[0] || Dir.pwd
+# --gollum-path wins over ARGV[0]
+gollum_path = wiki_options[:gollum_path] ?
+              wiki_options[:gollum_path] :
+              ARGV[0] || Dir.pwd
 
-Precious::App.run!(options)
+if options['irb']
+  require 'irb'
+  # http://jameskilton.com/2009/04/02/embedding-irb-into-your-ruby-application/
+  module IRB # :nodoc:
+    def self.start_session(binding)
+      unless @__initialized
+        args = ARGV
+        ARGV.replace(ARGV.dup)
+        IRB.setup(nil)
+        ARGV.replace(args)
+        @__initialized = true
+      end
+
+      ws  = WorkSpace.new(binding)
+      irb = Irb.new(ws)
+
+      @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+      @CONF[:MAIN_CONTEXT] = irb.context
+
+      catch(:IRB_EXIT) do
+        irb.eval_input
+      end
+    end
+  end
+
+  begin
+    require 'gollum-lib'
+    wiki = Gollum::Wiki.new(gollum_path, wiki_options)
+    if !wiki.exist? then raise Grit::InvalidGitRepositoryError end
+    puts "Loaded Gollum wiki at #{File.expand_path(gollum_path).inspect}."
+    puts
+    puts %(    page = wiki.page('page-name'))
+    puts %(    # => <Gollum::Page>)
+    puts
+    puts %(    page.raw_data)
+    puts %(    # => "# My wiki page")
+    puts
+    puts %(    page.formatted_data)
+    puts %(    # => "<h1>My wiki page</h1>")
+    puts
+    puts "Check out the Gollum README for more."
+    IRB.start_session(binding)
+  rescue Grit::InvalidGitRepositoryError, Grit::NoSuchPathError
+    puts "Invalid Gollum wiki at #{File.expand_path(gollum_path).inspect}"
+    exit 0
+  end
+else
+  require 'gollum/app'
+  Precious::App.set(:gollum_path, gollum_path)
+  Precious::App.set(:wiki_options, wiki_options)
+
+  if cfg = options['config']
+    # If the path begins with a '/' it will be considered an absolute path,
+    # otherwise it will be relative to the CWD
+    cfg = File.join(Dir.getwd, cfg) unless cfg.slice(0) == File::SEPARATOR
+    require cfg
+  end
+
+  base_path = wiki_options[:base_path]
+
+  if wiki_options[:base_path].nil?
+    Precious::App.run!(options)
+  else
+    require 'rack'
+
+    class MapGollum
+      def initialize base_path
+        @mg = Rack::Builder.new do
+          map '/' do
+            run Proc.new { [ 302, {'Location'=> "/#{base_path}" }, [] ] }
+          end
+
+          map "/#{base_path}" do
+            run Precious::App
+          end
+        end
+      end
+
+      def call(env)
+        @mg.call(env)
+      end
+    end
+    # Rack::Handler does not work with Ctrl + C. Use Rack::Server instead.
+    Rack::Server.new(:app => MapGollum.new(base_path), :Port => options['port'], :Host => options['bind']).start
+  end
+end

config.rb

@@ -0,0 +1,28 @@
+# Example gollum config
+# gollum ../wiki --config config.rb
+#
+# or run from source with
+#
+# bundle exec bin/gollum ../wiki/ --config config.rb
+
+# Remove const to avoid
+# warning: already initialized constant FORMAT_NAMES
+#
+# only remove if it's defined.
+# constant Gollum::Page::FORMAT_NAMES not defined (NameError)
+Gollum::Page.send :remove_const, :FORMAT_NAMES if defined? Gollum::Page::FORMAT_NAMES
+# limit to one format
+Gollum::Page::FORMAT_NAMES = { :markdown  => "Markdown" }
+
+=begin
+Valid formats are:
+{ :markdown  => "Markdown",
+  :textile   => "Textile",
+  :rdoc      => "RDoc",
+  :org       => "Org-mode",
+  :creole    => "Creole",
+  :rest      => "reStructuredText",
+  :asciidoc  => "AsciiDoc",
+  :mediawiki => "MediaWiki",
+  :pod       => "Pod" }
+=end

lib/gollum.rb

@@ -1,5 +1,8 @@
+# ~*~ encoding: utf-8 ~*~
 # stdlib
 require 'digest/md5'
+require 'digest/sha1'
+require 'ostruct'
 
 # external
 require 'grit'
@@ -7,52 +10,32 @@ require 'github/markup'
 require 'sanitize'
 
 # internal
-require 'gollum/pagination'
-require 'gollum/wiki'
-require 'gollum/page'
-require 'gollum/file'
-require 'gollum/markup'
-require 'gollum/albino'
+require File.expand_path('../gollum/uri_encode_component', __FILE__)
+
+# Set ruby to UTF-8 mode
+# This is required for Ruby 1.8.7 which gollum still supports.
+$KCODE = 'U' if RUBY_VERSION[0,3] == '1.8'
 
 module Gollum
-  VERSION = '1.0.0'
+  VERSION = '2.4.13'
 
-  SANITIZATION_OPTIONS = {
-    :elements => [
-      'a', 'abbr', 'acronym', 'address', 'area', 'b', 'big',
-      'blockquote', 'br', 'button', 'caption', 'center', 'cite',
-      'code', 'col', 'colgroup', 'dd', 'del', 'dfn', 'dir',
-      'div', 'dl', 'dt', 'em', 'fieldset', 'font', 'form', 'h1',
-      'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'input',
-      'ins', 'kbd', 'label', 'legend', 'li', 'map', 'menu',
-      'ol', 'optgroup', 'option', 'p', 'pre', 'q', 's', 'samp',
-      'select', 'small', 'span', 'strike', 'strong', 'sub',
-      'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th',
-      'thead', 'tr', 'tt', 'u', 'ul', 'var'
-    ],
-    :attributes => {
-      :all => ['abbr', 'accept', 'accept-charset',
-               'accesskey', 'action', 'align', 'alt', 'axis',
-               'border', 'cellpadding', 'cellspacing', 'char',
-               'charoff', 'charset', 'checked', 'cite',
-               'class', 'clear', 'cols', 'colspan', 'color',
-               'compact', 'coords', 'datetime', 'dir',
-               'disabled', 'enctype', 'for', 'frame',
-               'headers', 'height', 'href', 'hreflang',
-               'hspace', 'id', 'ismap', 'label', 'lang',
-               'longdesc', 'maxlength', 'media', 'method',
-               'multiple', 'name', 'nohref', 'noshade',
-               'nowrap', 'prompt', 'readonly', 'rel', 'rev',
-               'rows', 'rowspan', 'rules', 'scope',
-               'selected', 'shape', 'size', 'span', 'src',
-               'start', 'summary', 'tabindex', 'target',
-               'title', 'type', 'usemap', 'valign', 'value',
-               'vspace', 'width']
-    },
-    :protocols => {
-      'a' => {'href' => ['http', 'https', 'mailto', :relative]},
-      'img' => {'href' => ['http', 'https', :relative]}
-    }
-  }
+  def self.assets_path
+    ::File.expand_path('gollum/public', ::File.dirname(__FILE__))
+  end
+
+  class Error < StandardError; end
+
+  class DuplicatePageError < Error
+    attr_accessor :dir
+    attr_accessor :existing_path
+    attr_accessor :attempted_path
+
+    def initialize(dir, existing, attempted, message = nil)
+      @dir            = dir
+      @existing_path  = existing
+      @attempted_path = attempted
+      super(message || "Cannot write #{@dir}/#{@attempted_path}, found #{@dir}/#{@existing_path}.")
+    end
+  end
 end
 

lib/gollum/albino.rb

@@ -1,17 +0,0 @@
-require 'albino'
-
-class Gollum::Albino < Albino
-  def self.bin
-    Albino.bin
-  end
-
-  def bin
-    Albino.bin
-  end
-
-  def colorize(options = {})
-    html = super.to_s
-    html.sub!(%r{</pre></div>\Z}, "</pre>\n</div>")
-    html
-  end
-end

lib/gollum/app.rb

@@ -0,0 +1,439 @@
+# ~*~ encoding: utf-8 ~*~
+require 'cgi'
+require 'sinatra'
+require 'gollum-lib'
+require 'mustache/sinatra'
+require 'useragent'
+require 'stringex'
+
+require 'gollum'
+require 'gollum/views/layout'
+require 'gollum/views/editable'
+require 'gollum/views/has_page'
+
+require File.expand_path '../helpers', __FILE__
+
+# Fix to_url
+class String
+  alias :upstream_to_url :to_url
+  # _Header => header which causes errors
+  def to_url
+    return nil if self.nil?
+    upstream_to_url :exclude => ['_Header', '_Footer', '_Sidebar']
+  end
+end
+
+# Run the frontend, based on Sinatra
+#
+# There are a number of wiki options that can be set for the frontend
+#
+# Example
+# require 'gollum/app'
+# Precious::App.set(:wiki_options, {
+#     :universal_toc => false,
+# }
+#
+# See the wiki.rb file for more details on wiki options
+module Precious
+  class App < Sinatra::Base
+    register Mustache::Sinatra
+    include Precious::Helpers
+
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    # Detect unsupported browsers.
+    Browser = Struct.new(:browser, :version)
+
+    @@min_ua = [
+        Browser.new('Internet Explorer', '10.0'),
+        Browser.new('Chrome', '7.0'),
+        Browser.new('Firefox', '4.0'),
+    ]
+
+    def supported_useragent?(user_agent)
+      ua = UserAgent.parse(user_agent)
+      @@min_ua.detect {|min| ua >= min }
+    end
+
+    # We want to serve public assets for now
+    set :public_folder, "#{dir}/public/gollum"
+    set :static,         true
+    set :default_markup, :markdown
+
+    set :mustache, {
+      # Tell mustache where the Views constant lives
+      :namespace => Precious,
+
+      # Mustache templates live here
+      :templates => "#{dir}/templates",
+
+      # Tell mustache where the views are
+      :views => "#{dir}/views"
+    }
+
+    # Sinatra error handling
+    configure :development, :staging do
+      enable :show_exceptions, :dump_errors
+      disable :raise_errors, :clean_trace
+    end
+
+    configure :test do
+      enable :logging, :raise_errors, :dump_errors
+    end
+
+    before do
+      @base_url = url('/', false).chomp('/')
+      # above will detect base_path when it's used with map in a config.ru
+      settings.wiki_options.merge!({ :base_path => @base_url })
+      @css = settings.wiki_options[:css]
+      @js = settings.wiki_options[:js]
+    end
+
+    get '/' do
+      page_dir = settings.wiki_options[:page_file_dir].to_s
+      redirect clean_url(::File.join(@base_url, page_dir, wiki_new.index_page))
+    end
+
+    # path is set to name if path is nil.
+    #   if path is 'a/b' and a and b are dirs, then
+    #   path must have a trailing slash 'a/b/' or
+    #   extract_path will trim path to 'a'
+    # name, path, version
+    def wiki_page(name, path = nil, version = nil, exact = true)
+      wiki = wiki_new
+      
+      path = name if path.nil?
+      name = extract_name(name) || wiki.index_page
+      path = extract_path(path)
+      path = '/' if exact && path.nil?
+
+      OpenStruct.new(:wiki => wiki, :page => wiki.paged(name, path, exact, version),
+                     :name => name, :path => path)
+    end
+
+    def wiki_new
+      Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+    end
+
+    get '/data/*' do
+      if page = wiki_page(params[:splat].first).page
+        page.raw_data
+      end
+    end
+
+    get '/edit/*' do
+      wikip = wiki_page(params[:splat].first)
+      @name = wikip.name
+      @path = wikip.path
+      
+      wiki = wikip.wiki
+      if page = wikip.page
+        if wiki.live_preview && page.format.to_s.include?('markdown') && supported_useragent?(request.user_agent)
+          live_preview_url = '/livepreview/index.html?page=' + encodeURIComponent(@name)
+          if @path
+            live_preview_url << '&path=' + encodeURIComponent(@path)
+          end
+          redirect to(live_preview_url)
+        else
+          @page = page
+          @page.version = wiki.repo.log(wiki.ref, @page.path).first
+          raw_data = page.raw_data
+          @content = raw_data.respond_to?(:force_encoding) ? raw_data.force_encoding('UTF-8') : raw_data
+          mustache :edit
+        end
+      else
+        redirect to("/create/#{encodeURIComponent(@name)}")
+      end
+    end
+
+    post '/rename/*' do
+      wikip     = wiki_page(params[:splat].first)
+      halt 500 if wikip.nil?
+      wiki      = wikip.wiki
+      page      = wiki.paged(wikip.name, wikip.path, exact = true)
+      rename    = params[:rename]
+      halt 500 if page.nil?
+      halt 500 if rename.nil? or rename.empty?
+
+      # Fixup the rename if it is a relative path
+      # In 1.8.7 rename[0] != rename[0..0]
+      if rename[0..0] != '/'
+        source_dir = ::File.dirname(page.path)
+        source_dir = '' if source_dir == '.'
+        (target_dir, target_name) = ::File.split(rename)
+        target_dir = target_dir == '' ? source_dir : "#{source_dir}/#{target_dir}"
+        rename = "#{target_dir}/#{target_name}"
+      end
+
+      committer = Gollum::Committer.new(wiki, commit_message)
+      commit    = {:committer => committer}
+
+      success = wiki.rename_page(page, rename, commit)
+      if !success
+          # This occurs on NOOPs, for example renaming A => A
+          redirect to("/#{page.escaped_url_path}")
+          return
+      end
+      committer.commit
+
+      wikip = wiki_page(rename)
+      page = wiki.paged(wikip.name, wikip.path, exact = true)
+      return if page.nil?
+      redirect to("/#{page.escaped_url_path}")
+    end
+
+    post '/edit/*' do
+      path      = '/' + clean_url(sanitize_empty_params(params[:path])).to_s
+      page_name = CGI.unescape(params[:page])
+      wiki      = wiki_new
+      page      = wiki.paged(page_name, path, exact = true)
+      return if page.nil?
+      committer = Gollum::Committer.new(wiki, commit_message)
+      commit    = {:committer => committer}
+
+      update_wiki_page(wiki, page, params[:content], commit, page.name, params[:format])
+      update_wiki_page(wiki, page.header,  params[:header],  commit) if params[:header]
+      update_wiki_page(wiki, page.footer,  params[:footer],  commit) if params[:footer]
+      update_wiki_page(wiki, page.sidebar, params[:sidebar], commit) if params[:sidebar]
+      committer.commit
+
+      redirect to("/#{page.escaped_url_path}") unless page.nil?
+    end
+
+    get '/delete/*' do
+      wikip = wiki_page(params[:splat].first)
+      name = wikip.name
+      wiki = wikip.wiki
+      page = wikip.page
+      wiki.delete_page(page, { :message => "Destroyed #{name} (#{page.format})" })
+
+      redirect to('/')
+    end
+
+    get '/create/*' do
+      wikip = wiki_page(params[:splat].first.gsub('+', '-'))
+      @name = wikip.name.to_url
+      @path = wikip.path
+
+      page_dir = settings.wiki_options[:page_file_dir].to_s
+      unless page_dir.empty?
+        # --page-file-dir docs
+        # /docs/Home should be created in /Home
+        # not /docs/Home because write_page will append /docs
+        @path = @path.sub(page_dir, '/') if @path.start_with? page_dir
+      end
+
+      page = wikip.page
+      if page
+        page_dir = settings.wiki_options[:page_file_dir].to_s
+        redirect to("/#{clean_url(::File.join(page_dir, page.escaped_url_path))}")
+      else
+        mustache :create
+      end
+    end
+
+    post '/create' do
+      name         = params[:page].to_url
+      path         = sanitize_empty_params(params[:path]) || ''
+      format       = params[:format].intern
+      wiki = wiki_new
+
+      begin
+        wiki.write_page(name, format, params[:content], commit_message, path)
+
+        page_dir = settings.wiki_options[:page_file_dir].to_s
+        redirect to("/#{clean_url(::File.join(page_dir, path, name))}")
+      rescue Gollum::DuplicatePageError => e
+        @message = "Duplicate page: #{e.message}"
+        mustache :error
+      end
+    end
+
+    post '/revert/:page/*' do
+      wikip        = wiki_page(params[:page])
+      @path        = wikip.path
+      @name        = wikip.name
+      wiki         = wikip.wiki
+      @page        = wiki.paged(@name,@path)
+      shas         = params[:splat].first.split("/")
+      sha1         = shas.shift
+      sha2         = shas.shift
+
+      commit = commit_message
+      commit[:message] = "Revert commit #{sha1.chars.take(7).join}"
+      if wiki.revert_page(@page, sha1, sha2, commit)
+        redirect to("/#{@page.escaped_url_path}")
+      else
+        sha2, sha1 = sha1, "#{sha1}^" if !sha2
+        @versions  = [sha1, sha2]
+        diffs      = wiki.repo.diff(@versions.first, @versions.last, @page.path)
+        @diff      = diffs.first
+        @message   = "The patch does not apply."
+        mustache :compare
+      end
+    end
+
+    post '/preview' do
+      wiki     = wiki_new
+      @name    = params[:page] || "Preview"
+      @page    = wiki.preview_page(@name, params[:content], params[:format])
+      @content = @page.formatted_data
+      @toc_content = wiki.universal_toc ? @page.toc_data : nil
+      @mathjax = wiki.mathjax
+      @h1_title = wiki.h1_title
+      @editable = false
+      mustache :page
+    end
+
+    get '/history/*' do
+      @page        = wiki_page(params[:splat].first).page
+      @page_num    = [params[:page].to_i, 1].max
+      @versions    = @page.versions :page => @page_num
+      mustache :history
+    end
+
+    post '/compare/*' do
+      @file     = params[:splat].first
+      @versions = params[:versions] || []
+      if @versions.size < 2
+        redirect to("/history/#{@file}")
+      else
+        redirect to("/compare/%s/%s...%s" % [
+          @file,
+          @versions.last,
+          @versions.first]
+        )
+      end
+    end
+
+    get %r{
+      /compare/ # match any URL beginning with /compare/
+      (.+)      # extract the full path (including any directories)
+      /         # match the final slash
+      ([^.]+)   # match the first SHA1
+      \.{2,3}   # match .. or ...
+      (.+)      # match the second SHA1
+    }x do |path, start_version, end_version|
+      wikip        = wiki_page(path)
+      @path        = wikip.path
+      @name        = wikip.name
+      @versions    = [start_version, end_version]
+      wiki         = wikip.wiki
+      @page        = wikip.page
+      diffs        = wiki.repo.diff(@versions.first, @versions.last, @page.path)
+      @diff        = diffs.first
+      mustache :compare
+    end
+
+    get %r{/(.+?)/([0-9a-f]{40})} do
+      file_path = params[:captures][0]
+      version   = params[:captures][1]
+      wikip     = wiki_page(file_path, file_path, version)
+      name      = wikip.name
+      path      = wikip.path
+      if page = wikip.page
+        @page = page
+        @name = name
+        @content = page.formatted_data
+        mustache :page
+      else
+        halt 404
+      end
+    end
+
+    get '/search' do
+      @query = params[:q]
+      wiki = wiki_new
+      # Sort wiki search results by count (desc) and then by name (asc)
+      @results = wiki.search(@query).sort{ |a, b| (a[:count] <=> b[:count]).nonzero? || b[:name] <=> a[:name] }.reverse
+      @name = @query
+      mustache :search
+    end
+
+    get %r{
+      /pages  # match any URL beginning with /pages
+      (?:     # begin an optional non-capturing group
+        /(.+) # capture any path after the "/pages" excluding the leading slash
+      )?      # end the optional non-capturing group
+    }x do |path|
+      @path        = extract_path(path) if path
+      wiki_options = settings.wiki_options.merge({ :page_file_dir => @path })
+      wiki         = Gollum::Wiki.new(settings.gollum_path, wiki_options)
+      @results     = wiki.pages
+      @results     += wiki.files if settings.wiki_options[:show_all]
+      @ref         = wiki.ref
+      mustache :pages
+    end
+
+    get '/fileview' do
+      wiki = wiki_new
+      options = settings.wiki_options
+      content = wiki.pages
+      # if showing all files include wiki.files
+      content += wiki.files if options[:show_all]
+
+      # must pass wiki_options to FileView
+      # --show-all and --collapse-tree can be set.
+      @results = Gollum::FileView.new(content, options).render_files
+      @ref = wiki.ref
+      mustache :file_view, { :layout => false }
+    end
+
+    get '/*' do
+      show_page_or_file(params[:splat].first)
+    end
+
+    def show_page_or_file(fullpath)
+      wiki = wiki_new
+
+      name = extract_name(fullpath) || wiki.index_page
+      path = extract_path(fullpath) || '/'
+
+      if page = wiki.paged(name, path, exact = true)
+        @page = page
+        @name = name
+        @content  = page.formatted_data
+  
+        # Extensions and layout data
+        @editable = true
+        @toc_content = wiki.universal_toc ? @page.toc_data : nil
+        @mathjax  = wiki.mathjax
+        @h1_title = wiki.h1_title
+        @bar_side  = wiki.bar_side
+        
+        mustache :page
+      elsif file = wiki.file(fullpath)
+        content_type file.mime_type
+        file.raw_data
+      else
+        page_path = [path, name].compact.join('/')
+        redirect to("/create/#{clean_url(encodeURIComponent(page_path))}")
+      end
+    end
+
+    def update_wiki_page(wiki, page, content, commit, name = nil, format = nil)
+      return if !page ||
+        ((!content || page.raw_data == content) && page.format == format)
+      name    ||= page.name
+      format    = (format || page.format).to_sym
+      content ||= page.raw_data
+      wiki.update_page(page, name, format, content.to_s, commit)
+    end
+
+    private
+
+    # Options parameter to Gollum::Committer#initialize
+    #     :message   - The String commit message.
+    #     :name      - The String author full name.
+    #     :email     - The String email address.
+    # message is sourced from the incoming request parameters
+    # author details are sourced from the session, to be populated by rack middleware ahead of us
+    def commit_message
+      msg = (params[:message].nil? or params[:message].empty?) ? "[no message]" : params[:message]
+      commit_message = { :message => msg }
+      author_parameters = session['gollum.author']
+      commit_message.merge! author_parameters unless author_parameters.nil?
+      commit_message
+    end
+  end
+end

lib/gollum/file.rb

@@ -1,60 +0,0 @@
-module Gollum
-  class File
-    Wiki.file_class = self
-
-    # Public: Initialize a file.
-    #
-    # wiki - The Gollum::Wiki in question.
-    #
-    # Returns a newly initialized Gollum::File.
-    def initialize(wiki)
-      @wiki = wiki
-      @blob = nil
-      @path = nil
-    end
-
-    # Public: The on-disk filename of the file.
-    #
-    # Returns the String name.
-    def name
-      @blob && @blob.name
-    end
-
-    # Public: The raw contents of the page.
-    #
-    # Returns the String data.
-    def raw_data
-      @blob && @blob.data
-    end
-
-    # Public: The Grit::Commit version of the file.
-    attr_reader :version
-
-    # Public: The String path of the file.
-    attr_reader :path
-
-    #########################################################################
-    #
-    # Internal Methods
-    #
-    #########################################################################
-
-    # Find a file in the given Gollum repo.
-    #
-    # name    - The full String path.
-    # version - The String version ID to find.
-    #
-    # Returns a Gollum::File or nil if the file could not be found.
-    def find(name, version)
-      commit = @wiki.repo.commit(version)
-      if blob = commit.tree / name
-        @blob    = blob
-        @path    = name
-        @version = commit
-        self
-      else
-        nil
-      end
-    end
-  end
-end

lib/gollum/frontend/app.rb

@@ -1,154 +0,0 @@
-require 'sinatra'
-require 'gollum'
-require 'mustache/sinatra'
-
-require 'gollum/frontend/views/layout'
-require 'gollum/frontend/views/editable'
-
-module Precious
-  class App < Sinatra::Base
-    register Mustache::Sinatra
-
-    dir = File.dirname(File.expand_path(__FILE__))
-
-    # We want to serve public assets for now
-    set :public,    "#{dir}/public"
-    set :static,    true
-
-    set :mustache, {
-      # Tell mustache where the Views constant lives
-      :namespace => Precious,
-
-      # Mustache templates live here
-      :templates => "#{dir}/templates",
-
-      # Tell mustache where the views are
-      :views => "#{dir}/views"
-    }
-
-    # Sinatra error handling
-    configure :development, :staging do
-      set :raise_errors, false
-      set :show_exceptions, true
-      set :dump_errors, true
-      set :clean_trace, false
-    end
-
-    get '/' do
-      show_page_or_file('Home')
-    end
-
-    get '/edit/:name' do
-      @name = params[:name]
-      wiki = Gollum::Wiki.new($path)
-      if page = wiki.page(@name)
-        @page = page
-        @content = page.raw_data
-        mustache :edit
-      else
-        mustache :create
-      end
-    end
-
-    post '/edit/:name' do
-      name   = params[:name]
-      wiki   = Gollum::Wiki.new($path)
-      page   = wiki.page(name)
-      format = params[:format].intern
-      name   = params[:rename] if params[:rename]
-
-      wiki.update_page(page, name, format, params[:content], commit_message)
-
-      redirect "/#{Gollum::Page.cname name}"
-    end
-
-    post '/create/:name' do
-      name = params[:page]
-      wiki = Gollum::Wiki.new($path)
-
-      format = params[:format].intern
-
-      wiki.write_page(name, format, params[:content], commit_message)
-      redirect "/#{name}"
-    end
-
-    post '/preview' do
-      format = params['wiki_format']
-      data = params['text']
-      wiki = Gollum::Wiki.new($path)
-      wiki.preview_page("Preview", data, format).formatted_data
-    end
-
-    get '/history/:name' do
-      @name     = params[:name]
-      wiki      = Gollum::Wiki.new($path)
-      @page     = wiki.page(@name)
-      @page_num = [params[:page].to_i, 1].max
-      @versions = @page.versions :page => @page_num
-      mustache :history
-    end
-
-    post '/compare/:name' do
-      @versions = params[:versions] || []
-      if @versions.size < 2
-        redirect "/history/#{params[:name]}"
-      else
-        redirect "/compare/%s/%s...%s" % [
-          params[:name],
-          @versions.last,
-          @versions.first]
-      end
-    end
-
-    get '/compare/:name/:version_list' do
-      @name     = params[:name]
-      @versions = params[:version_list].split(/\.{2,3}/)
-      wiki      = Gollum::Wiki.new($path)
-      @page     = wiki.page(@name)
-      diffs     = wiki.repo.diff(@versions.first, @versions.last, @page.path)
-      @diff     = diffs.first
-      mustache :compare
-    end
-
-    get %r{/(.+?)/([0-9a-f]{40})} do
-      name = params[:captures][0]
-      wiki = Gollum::Wiki.new($path)
-      if page = wiki.page(name, params[:captures][1])
-        @page = page
-        @name = name
-        @content = page.formatted_data
-        mustache :page
-      else
-        halt 404
-      end
-    end
-
-    get '/*' do
-      show_page_or_file(params[:splat].first)
-    end
-
-    def show_page_or_file(name)
-      wiki = Gollum::Wiki.new($path)
-      if page = wiki.page(name)
-        @page = page
-        @name = name
-        @content = page.formatted_data
-        mustache :page
-      elsif file = wiki.file(name)
-        file.raw_data
-      else
-        @name = name
-        mustache :create
-      end
-    end
-
-    def commit_message
-      message = params[:message]
-      author_name = `git config --get user.name`.strip || 'Anonymous'
-      author_email = `git config --get user.email`.strip || 'anon@anon.com'
-      { :message => message,
-        :name => author_name,
-        :email => author_email }
-    end
-  end
-end

lib/gollum/frontend/public/css/editbar.css

@@ -1,194 +0,0 @@
-#editbar {
-  border-left: 1px solid #888;
-  border-top: 1px solid #888;
-  border-right:  1px solid #888;
-  overflow: hidden;
-  font-family: sans-serif;
-  font-size: 13px;
-}
-
-  #editbar .inner {
-    width: 100%;
-    padding: 0;
-    margin: 0;
-    border: none;
-  }
-
-  #editbar .current {
-    display: block !important;
-  }
-
-  #editbar .menu {
-    overflow: hidden;
-    background: white;
-    background: -webkit-gradient(linear, left top, left bottom, from(#fff), to(#EBF1FF));
-    background: -moz-linear-gradient(top,  #fff,  #EBF1FF);
-  }
-
-  #editbar .group {
-    float: left;
-    height: 26px;
-    margin: 3px;
-    padding-right: 6px;
-  }
-
-  #editbar .group-right {
-    float: right;
-  }
-
-    #editbar .group-right .tab.format {
-      margin-top: 4px;
-    }
-
-  #editbar .group-separator {
-    border-right: 1px solid #ddd;
-  }
-
-    #editbar .button {
-      width: 22px;
-      height: 22px;
-      background: #e7ecfb url(/images/editbar-buttons.png);
-      border: 1px solid #ddd;
-      text-indent: -100px;
-      cursor: pointer;
-      overflow: hidden;
-      padding: 1px;
-      display: block;
-      float: left;
-      margin: 0 2px;
-      -moz-border-radius: 2px;
-      -webkit-border-radius: 2px;
-      -khtml-border-radius: 2px;
-      border-radius: 2px;
-      background-repeat: no-repeat;
-    }
-
-    #editbar .button:hover {
-      background-color: #d9dde7;
-      border-color: #aaa;
-    }
-
-    #editbar .bold {
-      background-position: -97px 4px;
-    }
-
-    #editbar .italic {
-      background-position: -147px 4px;
-    }
-
-    #editbar .link {
-      background-position: -197px 4px;
-    }
-
-    #editbar .image {
-      background-position: -247px 4px;
-    }
-
-    #editbar .ul {
-      background-position: 3px 4px;
-    }
-
-    #editbar .ol {
-      background-position: -47px 4px;
-    }
-
-  #editbar .tab {
-    float: left;
-    display: block;
-  }
-
-    #editbar .tab a {
-      cursor: pointer;
-      display: inline-block;
-      float: left;
-      height: 26px;
-      padding-left: 18px;
-      padding-right: 12px;
-      line-height: 26px;
-      text-decoration: none;
-      background-image: url(/images/twiddle-right.png);
-      background-position: 0 50%;
-      background-repeat: no-repeat;
-      color: blue;
-    }
-
-    #editbar .tab a.open {
-      background-image: url(/images/twiddle-down.png);
-      color: #333;
-    }
-
-    #editbar .tab a.open:hover {
-      text-decoration: none;
-    }
-
-    #editbar .tab a:hover {
-      text-decoration: underline;
-    }
-
-  #editbar .sections {
-    clear: both;
-    float: left;
-    width: 100%;
-    overflow: visible;
-    border-top: 1px solid #888;
-    height: 185px;
-    background-color: #E0EEF7;
-    display: none;
-  }
-
-    #editbar .sections .toc {
-      float: left;
-      width: 20%;
-      overflow: auto;
-    }
-
-      #editbar .sections .toc div {
-        cursor: pointer;
-        padding: 4px 4px 4px 6px;
-        background-color: #E0EEF7;
-        color: blue;
-      }
-
-      #editbar .sections .toc div.current {
-        cursor: default;
-        background-color: white;
-        color: #333;
-      }
-
-    #editbar .sections .pages {
-      overflow: auto;
-      background-color: white;
-      float: right;
-      width: 80%;
-      height: 185px;
-    }
-
-      #editbar .sections .page {
-        display: none;
-      }
-
-      #editbar .sections .pages th {
-        color: #999;
-        font-weight: bold;
-        padding: 5px;
-        text-align: left;
-      }
-
-      #editbar .sections .pages td {
-        color: black;
-        padding: 5px;
-        border-top: 1px solid #eee;
-      }
-
-      #editbar .sections .pages span.invisible {
-        color: #bbb;
-        padding-left: 1px;
-      }
-
-      #editbar .sections .pages .shortcodes th {
-        text-align: center;
-      }
-
-      #editbar .sections .pages .shortcodes ul {
-        list-style-type: none;
-      }

lib/gollum/frontend/public/css/gollum.css

@@ -1,55 +0,0 @@
-a.absent {
-  color: #a00;
-}
-
-/* Images */
-
-.frame {
-  margin: 0;
-  display: inline-block;
-}
-
-.frame img {
-  display: block;
-}
-
-.frame > span {
-  display: block;
-  border: 1px solid #aaa;
-  padding: 4px;
-}
-
-.frame span span {
-  display: block;
-  font-size: 10pt;
-  margin: 0;
-  padding: 4px 0 2px 0;
-  text-align: center;
-  line-height: 10pt;
-  font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
-}
-
-.float-left {
-  float: left;
-  padding: .5em 1em .25em 0;
-}
-
-.float-right {
-  float: right;
-  padding: .5em 0 .25em 1em;
-}
-
-.align-left {
-  display: block;
-  text-align: left;
-}
-
-.align-center {
-  display: block;
-  text-align: center;
-}
-
-.align-right {
-  display: block;
-  text-align: right;
-}

lib/gollum/frontend/public/css/screen.css

@@ -1,726 +0,0 @@
-/****************************************************************************/
-/* Base
-/****************************************************************************/
-
-* {
-  margin: 0;
-  padding: 0;
-}
-
-html, body {
-  height: 100%;
-  color: black;
-}
-
-body {
-  background-color: white;
-  font: 13.34px helvetica, arial, freesans, clean, sans-serif;
-  *font-size: small;
-}
-
-table {
-  font-size: inherit;
-  font: 100%;
-}
-
-select, input[type=text], input[type=password], input[type=image], textarea {
-  font: 99% helvetica, arial, freesans, sans-serif;
-}
-select, option {
-  padding: 0 .25em;
-}
-optgroup {
-  margin-top: .5em;
-}
-
-input.text {
-  padding: 1px 0;
-}
-pre, code {
-  font: 12px Monaco, "Courier New", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", monospace;
-}
-
-body * {
-  line-height: 1.4em;
-}
-
-p{ margin:1em 0; }
-
-img {
-  border: 0;
-}
-
-abbr {
-  border-bottom: none;
-}
-
-.clearfix:after {
-    content: ".";
-    display: block;
-    height: 0;
-    clear: both;
-    visibility: hidden;
-}
-* html .clearfix {height: 1%;}
-.clearfix {display:inline-block;}
-.clearfix {display: block;}
-
-/* always show vertical scroll bar to prevent page jitter */
-html {overflow-y: scroll;}
-
-.site {
-  margin: 2em auto 0 auto;
-  width: 920px;
-  padding: 0 15px;
-}
-
-/****************************************************************************/
-/* Guides
-/****************************************************************************/
-
-#guides {
-
-}
-
-  /* index */
-
-  #guides .index {
-
-  }
-
-    #guides h1 {
-      margin-bottom: .5em;
-    }
-
-    #guides .index ul {
-      list-style-type: none;
-      font-size: 120%;
-    }
-
-      #guides .index ul li {
-        padding-left: 1.5em;
-        background: white url(/images/modules/guides/book.png) no-repeat;
-      }
-
-    #guides .index .new {
-      margin-top: 1em;
-      border-top: 1px solid #ccc;
-      padding-top: .5em;
-    }
-
-      #guides .index .new ul li {
-        background: white url(/images/modules/guides/book_add.png) no-repeat;
-      }
-
-      #guides .index .new ul li a {
-        color: #c00;
-      }
-
-    #guides .write .delete_page {
-      float: right;
-    }
-
-  /* guide */
-
-  #guides .guide {
-    overflow: hidden;
-  }
-
-    /* main */
-
-    #guides .guide .main {
-      width: 100%;
-    }
-
-    /* sidebar */
-
-    #guides .guide .sidebar {
-      float: right;
-      width: 15em;
-      border-left: 4px solid #e6e6e6;
-      margin: 2.1em 0 0 0;
-      padding-left: 1em;
-    }
-
-      #guides .guide .sidebar h3 {
-        margin: 0 0 .5em 0;
-      }
-
-      #guides .guide .sidebar ul {
-        list-style-type: none;
-        margin: 0;
-        color: #888;
-
-      }
-
-      #guides .guide .sidebar ul li {
-        padding-left: 12px;
-        background: white url(/images/modules/guides/sidebar/bullet_blue.png) -4px 0 no-repeat;
-        margin: .2em 0;
-      }
-
-  /* admin */
-
-  #guides .admin {
-    clear: both;
-    margin-top: 3em;
-    border-top: 4px solid #e6e6e6;
-    padding-top: .3em;
-    overflow: hidden;
-  }
-
-  /* write */
-
-  #guides .write {
-
-  }
-
-    #guides .write label {
-      font-size: 110%;
-      color: #666;
-      display: block;
-      margin: 1em 0;
-    }
-
-    #guides .write input.text {
-      padding: 5px;
-      border: 1px solid #888;
-      width: 40em;
-    }
-
-    #guides .write textarea {
-      width: 100%;
-      height: 25em;
-      border: none;
-    }
-
-    #guides .write label span.title {
-      color: black;
-      font-weight: bold;
-    }
-
-    #guides .write .actions input {
-      margin-right: 1em;
-    }
-
-    #guides .write #preview_bucket {
-      border: 1px solid #888;
-      background-color: white;
-      padding: 5px;
-    }
-
-/****************************************************************************/
-/* Wiki
-/****************************************************************************/
-
-.wikistyle h1, .wikistyle h2, .wikistyle h3, .wikistyle h4, .wikistyle h5, .wikistyle h6 {
-  border: 0 !important;
-}
-
-.wikistyle h1 {
-  font-size: 170% !important;
-  border-top: 4px solid #aaa !important;
-  padding-top: .5em !important;
-  margin-top: 1.5em !important;
-}
-
-.wikistyle h2 {
-  font-size: 150% !important;
-  margin-top: 1.5em !important;
-  border-top: 4px solid #e0e0e0 !important;
-  padding-top: .5em !important;
-}
-
-.wikistyle h3 {
-  margin-top: 1em !important;
-}
-
-.wikistyle p {
-  margin: 1em 0 !important;
-  line-height: 1.5em !important;
-}
-
-.wikistyle ul {
-  margin: 1em 0 1em 2em !important;
-}
-
-.wikistyle ol {
-  margin: 1em 0 1em 2em !important;
-}
-
-.wikistyle ul ul,
-.wikistyle ul ol,
-.wikistyle ol ol,
-.wikistyle ol ul {
-  margin-top: 0 !important;
-  margin-bottom: 0 !important;
-}
-
-.wikistyle blockquote {
-  margin: 1em 0 !important;
-  border-left: 5px solid #ddd !important;
-  padding-left: .6em !important;
-  color: #555 !important;
-}
-
-.wikistyle dt {
-  font-weight: bold !important;
-  margin-left: 1em !important;
-}
-
-.wikistyle dd {
-  margin-left: 2em !important;
-  margin-bottom: 1em !important;
-}
-
-.wikistyle table {
-  margin: 1em 0 !important;
-}
-
-  .wikistyle table th {
-    border-bottom: 1px solid #bbb !important;
-    padding: .2em 1em !important;
-  }
-
-  .wikistyle table td {
-    border-bottom: 1px solid #ddd !important;
-    padding: .2em 1em !important;
-  }
-
-.wikistyle pre {
-  margin: 1em 0 !important;
-  font-size: 90% !important;
-  background-color: #f8f8ff !important;
-  border: 1px solid #dedede !important;
-  padding: .5em !important;
-  line-height: 1.5em !important;
-  color: #444 !important;
-  overflow: auto !important;
-}
-
-  .wikistyle pre code {
-    padding: 0 !important;
-    font-size: 100% !important;
-    background-color: #f8f8ff !important;
-    border: none !important;
-  }
-
-.wikistyle code {
-  font-size: 90% !important;
-  background-color: #f8f8ff !important;
-  color: #444 !important;
-  padding: 0 .2em !important;
-  border: 1px solid #dedede !important;
-}
-
-/* console */
-
-.wikistyle pre.console {
-  margin: 1em 0 !important;
-  font-size: 90% !important;
-  background-color: black !important;
-  padding: .5em !important;
-  line-height: 1.5em !important;
-  color: white !important;
-}
-
-  .wikistyle pre.console code {
-    padding: 0 !important;
-    font-size: 100% !important;
-    background-color: black !important;
-    border: none !important;
-    color: white !important;
-  }
-
-  .wikistyle pre.console span {
-    color: #888 !important;
-  }
-
-  .wikistyle pre.console span.command {
-    color: yellow !important;
-  }
-
-/* Wiki form */
-
-.wiki-form .inner {
-  margin: 0;
-  padding: 0 0 0 5px;
-  background: #fff;
-  border: solid 1px #888;
-  line-height: 0;
-}
-
-.wiki-form input[type=text] {
-  width: 100%;
-}
-
-label.wiki-label {
-  padding: 1em 5px;
-}
-
-/* Special markup considerations */
-
-.wikistyle.gollum.footer {
-  border-top: 4px solid #f0f0f0;
-  margin-top: 2em;
-}
-
-.wikistyle.gollum > h1:first-child {
-  display: none;
-}
-
-/* asciidoc */
-
-.wikistyle.gollum.asciidoc > div#header > h1:first-child {
-  display: none;
-}
-
-.wikistyle.gollum.asciidoc .ulist p,
-.wikistyle.gollum.asciidoc .olist p {
-  margin: 0 !important;
-}
-
-.wikistyle.gollum.asciidoc .loweralpha {
-  list-style-type: lower-alpha;
-}
-
-.wikistyle.gollum.asciidoc .lowerroman {
-  list-style-type: lower-roman;
-}
-
-.wikistyle.gollum.asciidoc .upperalpha {
-  list-style-type: upper-alpha;
-}
-
-.wikistyle.gollum.asciidoc .upperroman {
-  list-style-type: upper-roman;
-}
-
-/* org */
-
-.wikistyle.gollum.org > p.title:first-child {
-  display: none;
-}
-
-.wikistyle.gollum.org p:first-child + h1 {
-  border-top: none !important;
-}
-
-/* pod */
-
-.wikistyle.gollum.pod > a.dummyTopAnchor:first-child + h1 {
-  display: none;
-}
-
-.wikistyle.gollum.pod h1 a {
-  text-decoration: none;
-  color: inherit;
-}
-
-/* rest */
-
-.wikistyle.gollum.rest > div.document > div.section > h1:first-child {
-  display: none;
-}
-
-/****************************************************************************/
-/* Comment Form
-/****************************************************************************/
-
-.comment-form-error{
-  margin:-15px 0 15px 0;
-  font-weight:bold;
-  color:#aa0000;
-}
-
-.comment-form{
-  margin:-10px 0 10px 0;
-  padding:5px;
-  background:#eee;
-  -webkit-border-radius:5px;
-  -moz-border-radius:5px;
-}
-
-.comment-form textarea{
-  margin:0;
-  padding: 5px 0;
-  width:100%;
-  height:100px;
-}
-
-.comment-form p.help{
-  margin:3px 0 0 0;
-  float:right;
-  font-size:11px;
-  color:#666;
-}
-
-.comment-form ul.tabs{
-  margin:0 0 5px 0;
-}
-
-.comment-form ul.tabs li{
-  list-style-type:none;
-  margin:0;
-  display:inline-block;
-}
-
-.comment-form ul.tabs a{
-  display:inline-block;
-  padding:2px 8px;
-  font-size:11px;
-  font-weight:bold;
-  text-decoration:none;
-  color:#666;
-  border:1px solid transparent;
-  -webkit-border-radius:10px;
-  -moz-border-radius:10px;
-}
-
-.comment-form ul.tabs a.selected{
-  color:#333;
-  background:#fff;
-  border-color:#bbb;
-  border-right-color: #ddd;
-  border-bottom-color: #ddd;
-}
-
-.comment-form .comment{
-  margin:5px 0 0 0;
-}
-
-/****************************************************************************/
-/* History
-/****************************************************************************/
-
-table.commits {
-  width: 100%;
-  border-left: 1px solid #ccc;
-  border-right: 1px solid #ccc;
-  border-top: 1px solid #ccc;
-  margin-bottom: 2em;
-}
-
-  table.commits tr td {
-    background-color: #eaf2f5;
-  }
-
-    table.commits tr.selected td {
-      background-color: #FEFFE6;
-    }
-
-  table.commits th {
-    font-weight: normal;
-    border-bottom: 1px solid #ccc;
-    padding: .3em .6em;
-    background-color: #eee;
-    font-size: 95%;
-    text-align:left;
-  }
-
-  table.commits td {
-    border-bottom: 1px solid #ccc;
-    padding: .3em .6em;
-  }
-
-    table.commits td.sha,
-    table.commits td.message {
-      font-family: Monaco, "Courier New", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", monospace;
-      font-size: 80%;
-    }
-
-    table.commits td.checkbox {
-      width: 3%;
-    }
-
-    table.commits td.sha {
-      width: 6%;
-    }
-
-    table.commits td.human {
-      font-family: Monaco, "Courier New", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", monospace;
-      font-size: 80%;
-      width: 4%;
-      color: #888;
-    }
-
-    table.commits td.author {
-      width: 15%;
-      font-weight: bold;
-    }
-
-      table.commits td.author img {
-        vertical-align: middle;
-        border: 1px solid #ccc;
-        padding: 1px;
-        background-color: white;
-      }
-
-    table.commits td.message a {
-      color: black;
-    }
-
-      table.commits td.message a:hover {
-        text-decoration: underline;
-      }
-
-    table.commits td.date {
-      width: 12%;
-      text-align: right;
-    }
-
-/****************************************************************************/
-/* Files
-/****************************************************************************/
-
-#files {
-
-}
-
-  #files .file {
-    border: 1px solid #ccc;
-    margin-bottom: 1em;
-  }
-
-  #files .file .syntax{
-    border:none;
-    padding:0;
-  }
-
-    #files .file .meta {
-      padding:0 5px;
-      height:33px;
-      line-height:33px;
-      font-size:12px;
-      color:#333;
-      background:url(/images/modules/commit/file_head.gif) 0 0 repeat-x #eee;
-      text-shadow:1px 1px 0 rgba(255, 255, 255, 0.5);
-      border-bottom: 1px solid #ccc;
-      overflow: hidden;
-    }
-
-      #files .file .meta .info {
-        float: left;
-        height:33px;
-        line-height:33px;
-        font-family: Monaco, "Courier New", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", monospace;
-      }
-
-        #files .file .meta .info span{
-          padding-left:9px;
-          margin-left:5px;
-          background:url(/images/modules/commit/action_separator.png) 0 50% no-repeat;
-        }
-
-        #files .file .meta .info span:first-child, #files .file .meta .info .icon + span{
-          background:transparent;
-          margin-left:0;
-          padding-left:0;
-        }
-
-        #files .file .meta .info span.icon{
-          float:left;
-          margin:5px 5px 0 0;
-          padding:3px;
-          background:#f7f7f7;
-          border:1px solid #ccc;
-          border-right-color:#e5e5e5;
-          border-bottom-color:#e5e5e5;
-          -webkit-border-radius:3px;
-          -moz-border-radius:3px;
-          border-radius:3px;
-          line-height: 1em;
-        }
-
-    #files .file .meta .actions {
-      float: right;
-      height:33px;
-      line-height:33px;
-    }
-
-      #files .file .meta .actions li{
-        list-style-type:none;
-        float:left;
-        margin:0 0 0 7px;
-        height:33px;
-        line-height:33px;
-        padding-left:9px;
-        font-size:11px;
-        background:url(/images/modules/commit/action_separator.png) 0 50% no-repeat;
-      }
-
-      #files .file .meta .actions li:first-child{
-        background:transparent;
-        margin-left:0;
-        padding-left:0;
-      }
-
-        #files .file .meta .actions li a{
-          font-weight:bold;
-        }
-
-        #files .file .meta .actions li code{
-          font-size:11px;
-        }
-
-        #files .file .meta .actions li label input{
-          position:relative;
-          top:1px;
-        }
-
-    #files .file .data {
-      font-size: 80%;
-      overflow: auto;
-      background-color: #f8f8ff;
-    }
-
-    #files .file .data.empty {
-      font-size: 90%;
-      padding:5px 10px;
-      color:#777;
-    }
-
-    #files .image {
-      padding: 1.2em;
-      text-align: center;
-    }
-
-      #files .image img {
-        max-width: 60em;
-      }
-
-      #files .file .data pre, #files .file .line-data, #files .file .line-number {
-        font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace;
-        font-size: 115%;
-      }
-
-        #files .file .data .highlight {
-          padding: 1em 0;
-        }
-
-        #files .file .data .highlight div {
-          padding-left: 1em;
-        }
-
-        #files .file .data .line_numbers {
-          background-color: #ececec;
-          color: #aaa;
-          padding: 1em .5em;
-          border-right: 1px solid #ddd;
-          text-align: right;
-        }
-
-        #files .file .data td.line_numbers{
-          padding:0 0.5em;
-          font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace;
-          font-size: 115%;
-          -moz-user-select:none;
-          -khtml-user-select:none;
-          user-select:none;
-        }
-
-          #files .file .data .line_numbers span,
-          #files .file .data .line_numbers a {
-            color: #aaa;
-            cursor: pointer;
-          }

lib/gollum/frontend/public/css/syntax.css

@@ -1,61 +0,0 @@
-.highlight  { background: #ffffff; }
-.highlight .c { color: #999988; font-style: italic } /* Comment */
-.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
-.highlight .k { font-weight: bold } /* Keyword */
-.highlight .o { font-weight: bold } /* Operator */
-.highlight .cm { color: #999988; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #999999; font-weight: bold } /* Comment.Preproc */
-.highlight .c1 { color: #999988; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #999999; font-weight: bold; font-style: italic } /* Comment.Special */
-.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
-.highlight .gd .x { color: #000000; background-color: #ffaaaa } /* Generic.Deleted.Specific */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #aa0000 } /* Generic.Error */
-.highlight .gh { color: #999999 } /* Generic.Heading */
-.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
-.highlight .gi .x { color: #000000; background-color: #aaffaa } /* Generic.Inserted.Specific */
-.highlight .gc { color: #999; background-color: #EAF2F5 }
-.highlight .go { color: #888888 } /* Generic.Output */
-.highlight .gp { color: #555555 } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #aaaaaa } /* Generic.Subheading */
-.highlight .gt { color: #aa0000 } /* Generic.Traceback */
-.highlight .kc { font-weight: bold } /* Keyword.Constant */
-.highlight .kd { font-weight: bold } /* Keyword.Declaration */
-.highlight .kp { font-weight: bold } /* Keyword.Pseudo */
-.highlight .kr { font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #445588; font-weight: bold } /* Keyword.Type */
-.highlight .m { color: #009999 } /* Literal.Number */
-.highlight .s { color: #d14 } /* Literal.String */
-.highlight .na { color: #008080 } /* Name.Attribute */
-.highlight .nb { color: #0086B3 } /* Name.Builtin */
-.highlight .nc { color: #445588; font-weight: bold } /* Name.Class */
-.highlight .no { color: #008080 } /* Name.Constant */
-.highlight .ni { color: #800080 } /* Name.Entity */
-.highlight .ne { color: #990000; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #990000; font-weight: bold } /* Name.Function */
-.highlight .nn { color: #555555 } /* Name.Namespace */
-.highlight .nt { color: #000080 } /* Name.Tag */
-.highlight .nv { color: #008080 } /* Name.Variable */
-.highlight .ow { font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #009999 } /* Literal.Number.Float */
-.highlight .mh { color: #009999 } /* Literal.Number.Hex */
-.highlight .mi { color: #009999 } /* Literal.Number.Integer */
-.highlight .mo { color: #009999 } /* Literal.Number.Oct */
-.highlight .sb { color: #d14 } /* Literal.String.Backtick */
-.highlight .sc { color: #d14 } /* Literal.String.Char */
-.highlight .sd { color: #d14 } /* Literal.String.Doc */
-.highlight .s2 { color: #d14 } /* Literal.String.Double */
-.highlight .se { color: #d14 } /* Literal.String.Escape */
-.highlight .sh { color: #d14 } /* Literal.String.Heredoc */
-.highlight .si { color: #d14 } /* Literal.String.Interpol */
-.highlight .sx { color: #d14 } /* Literal.String.Other */
-.highlight .sr { color: #009926 } /* Literal.String.Regex */
-.highlight .s1 { color: #d14 } /* Literal.String.Single */
-.highlight .ss { color: #990073 } /* Literal.String.Symbol */
-.highlight .bp { color: #999999 } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #008080 } /* Name.Variable.Class */
-.highlight .vg { color: #008080 } /* Name.Variable.Global */
-.highlight .vi { color: #008080 } /* Name.Variable.Instance */
-.highlight .il { color: #009999 } /* Literal.Number.Integer.Long */

lib/gollum/frontend/public/javascript/MathJax/COPYING.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

lib/gollum/frontend/public/javascript/MathJax/README.txt

@@ -1,480 +0,0 @@
-OVERVIEW:
-
-MathJax (TM) is an open source, Ajax-based math display solution designed
-with a goal of consolidating advances in many web technologies in a
-single definitive math-on-the-web platform supporting all major
-browsers.
-
-Some of the main features of MathJax include:
-
-  o High-quality display of LaTeX and MathML math notation in HTML pages
-
-  o Supported in most browsers with no plug-ins, extra fonts, or special
-    setup for the reader
-
-  o Easy for authors, flexible for publishers, extensible for developers
-
-  o Supports math accessibility, cut and paste interoperability and other
-    advanced functionality
-
-  o Powerful API for integration with other web applications
-
-See http://www.mathjax.org/ for additional details.
-
-
-INSTALLATION:
-
-MathJax can be used on a web server to support mathematics in your
-public web pages, or it can be used locally from your hard disk for
-your private pages.  To use MathJax in either way, you will need to
-obtain a copy of MathJax (see below) and its font package.  These two
-are separate pieces because the fonts are not likely to change often,
-while the main code will be updated fairly regularly.
-
-Obtaining MathJax from SourceForge via SVN:
-
-The easiest way to obtain MathJax and keep it up-to-date is to use the
-subversion program (svn) to check it out from the MathJax project at
-SourceForge.net.  The page
-
-    http://sourceforge.net/projects/mathjax/develop
-
-lists the command you need to use to obtain a copy of MathJax via svn.
-Once you have checked out a version of MathJax, you will find that it
-includes a file called "fonts.zip" in the top-level directory.  You
-will need to unpack that file in order to complete the installation of
-MathJax.  It will create a fonts directory that contains the web fonts
-and images fonts used by MathJax to support users who do not have math
-fonts installed on their computers.  Once you have checked out
-MathJax, you will need to move the MathJax directory to your web
-server in a location that is convenient for your use.
-
-Obtaining MathJax from SourceForge as an archive file:
-
-You can obtain MathJax from the MathJax project at SourceForge via
-the link
-
-    http://sourceforge.net/projects/mathjax/files/
-
-where you will need to download a copy of the MathJax ZIP file (for
-the current version) and the MathJax-webfonts ZIP file.  Unpack the
-MathJax ZIP file first, and then unpack the MathJax-webfonts ZIP file
-into that.  That should produce a fonts directory in the MathJax
-folder (and MathJax/fonts should contain an HTML-CSS directory).  The
-fonts directory contains web fonts and image fonts used by MathJax to
-support users who do not have math fonts installed on their
-computers.  Once you have unpacked both archives, you can move the
-MathJax directory to your web server in a location that is convenient
-for your use.
-
-
-TESTING MATHJAX:
-
-Once you have MathJax installed, you can use the files in the
-MathJax/test directory to test that your installation is working
-properly.  You can also use it to test if your version of MathJax
-needs updating.  If you have checked out MathJax using subversion
-(svn), you can simply use "svn status" to see if your installation
-needs to be updated, and "svn update" to get any updates.
-
-
-USING MATHJAX IN A WEB PAGE:
-
-To use MathJax in a web page, you need to load MathJax.js near the top of
-the document (preferably in the document HEAD).  A SCRIPT tag like
-
-    <script type="text/javascript" src="/MathJax/MathJax.js"></script>
-
-will do it if you have MathJax at the top level of your web server.
-When called in this form, MathJax can be configured through the file
-MathJax/config/MathJax.js, which contains the parameters that control
-MathJax.  There are comments in this file that explain what each of
-the parameters does, so look there for details.
-
-Alternatively, you can configure MathJax in-line within your web page
-(avoiding an extra file transfer).  To do that, place the
-configuration information within the SCRIPT tag itself, as in the
-following example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-        extensions: ["tex2jax.js","TeX/noErrors.js"],
-	jax: ["input/TeX","output/HTML-CSS"],
-	tex2jax: {inlineMath: [['$','$'],["\\(","\\)"]]},
-	"HTML-CSS": {availableFonts:["TeX"]}
-      });
-    </script>
-
-which loads the tex2jax preprocessor and an extension that causes TeX
-errors to show the original TeX code rather than an error message,
-specifies the input and output jax (input format is TeX and output
-format is HTML/CSS), configures the tex2jax preprocessor to allow
-dollar signs to delimit inline-math as well as \(...\), and forces the
-HTML/CSS output to use the MathJax TeX fonts (in particular, the STIX
-fonts won't be used.)
-
-If you configure MathJax in this fashion, the MathJax/config/MathJax.js
-file is not loaded, and your in-line configuration is used instead.  
-Note that you can include any of the parameters from the
-config/MathJax.js file (and in fact any arbitrary JavaScript as well).
-
-With the default configuration, MathJax runs the tex2jax preprocessor
-to look for TeX-style mathematics delimiters as a means of identifying
-the mathematics on the page.  This uses \(...\) to mark in-line
-mathematics and \[...\] or $$...$$ for displayed mathematics.  LaTeX
-environments can also mark mathematics, as in
-\begin{equation}...\end{equation}.  Once the preprocessor runs,
-MathJax will typeset the mathematics on the page.
-
-Note that there can not be HTML tags within the math delimiters (other
-than <BR>) as TeX-formatted math does not include HTML tags.  Also,
-since the mathematics is initially given as text on the page, you need
-to be careful that your mathematics doesn't look like HTML tags to the
-browser (which parses the page before MathJax gets to see it).  In
-particular, that means that you have to be careful about things like
-less-than and greater-than signs (<,>), and ampersands (&), which have
-special meaning to the browsers.  For example, 
-
-	... when $x<y$ we have ...
-
-will cause a problem, because the brower will think "<y" is the
-beginning of a tag named "y" (even though there is no such tag in
-HTML).  Usually, it is sufficient to simply put spaces around these
-symbols to cause the browser to avoid them, so 
-
-	... when $x < y$ we have ...
-
-should work.  Alternatively, you can use the HTML entities &lt;, &gt;
-and &amp; to encode these characters so that the browser will not
-interpret them, but MathJax will.  E.g., 
-
-	... when $x &lt; y$ we have ...
-
-Finally, there are \lt and \gt macros defined to make it easier to
-enter < and > using TeX-like syntax:
-
-        ... when $x \lt y$ we have ...
-
-Keep in mind that the browser interprets your text before MathJax
-does.
-
-
-MATHJAX WITH NO PREPROCESSOR:
-
-The usual way to use MathJax is with the tex2jax preprocessor, but if
-you are generating web pages via some other preprocessor of your own,
-you may wish to bypass the tex2math preprocessing and mark the
-mathematics in your page directly.  This avoids an extra file
-transfer, the time involed in running the tex2jax preprocessor, and
-the issues involving less-than, greater-than, and ampersand discussed
-in the section above.
-
-When MathJax processes a page, it looks for mathematics stored in
-special SCRIPT tags.  These are 
-
-    <script type="math/tex">...</script>
-
-for in-line math, and
-
-    <script type="math/tex; mode=display">...</script>
-
-for displayed math, where the contents of the SCRIPT tags are TeX or
-LaTeX mathematics.  Since SCRIPT tags can include less-than,
-greater-than, and ampersand characters, this neatly avoids the problem
-that these cause when you use the tex2jax preprocessor.
-
-Unfortunately, this method introduces a problem of its own, due to a
-bug in Internet Explorer.  The problem is that IE incorrectly removes
-blank spaces from the page in order to avoid what it considers to be
-multiple spaces in a row.  In particular, if there is a space both
-before and after a tag that IE thinks does not insert content into the
-page, it removes one of the two blanks.  Because SCRIPT tags don't
-get displayed, IE will remove one of the spaces, so
-
-    ... when <script type="math/tex">x < y</script> we have ...
-
-will become "...whenx < y we have..." in the output, with no space
-between the "when" and the "x".  Because the space is removed before
-MathJax runs, MathJax has no way to recover the missing space, as it
-simply is no longer part of the page as far as IE is concerned.
-
-MathJax provides two different mechanisms to avoid this problem.  One
-is to add a prefix or postfix for the mathematics tags, which is text
-that you insert before or after the tag that MathJax will remove when
-it processes the tag.  Patterns for the prefix and postfix are given
-in the "preJax" and "postJax" parameters of the MathJax.Hub.Config()
-command (see the MathJax/config/MathJax.js file for more details).
-For example, setting
-
-    preJax: "@@"
-
-would mean that
-
-    ... when @@<script type="math/tex">x < y</script> we have ...
-
-would produce ".. when x < y we have ..." properly typeset.  (One need
-not use both a preJax and postJax, as one is enough, but both are
-provided so that you can use either or both in combination.)  Note,
-however, that the "@@" in this example will be displayed as part of
-the page until MathJax processes the mathematics and replaces the
-preJax with the typeset mathematics.  This may cause visual confusion
-that disturbs your readers.  It might be better to use something like
-"[math]" as the text for the preJax, since this may make more sense to
-your readers.  Because the pre- and postJax are regular expression
-patterns (not litteral strings), you will need to handle this
-carefully because [ and ] have special meaning in regular expressions.
-Use
-
-    preJax: "\\[math\\]"
-
-to make preJax be "\[math\]" (the double backslashes are to quote the
-backslash as part of the JavaScript string, and the resulting \[ and
-\] quote these characters in the resulting regular expression so they
-are treated as literal characters rather than having their special
-meansings in regular expressions).
-
-The other approach is to use a "MathJax preview" before the SCRIPT
-tag.  This is a means by which you can supply an alternative form for
-the mathematics to be displayed prior to when MathJax runs.  You
-could use a simple HTML version (if the mathematics is simple enough),
-or an IMG tag, or just the raw TeX code, for example.  Note that the
-mathematics between the SCRIPT tags is NOT displayed (since it is a
-script, not text), so the preview can be used to show the TeX code up
-until the mathematics is typeset.  (The tex2jax preprocessor does that
-automatically, for example).  To make a preview, include a SPAN with
-CLASS="MathJax_Preview" as the element just before the math SCRIPT
-tag, e.g., 
-
-    ... when <span class="MathJax_Preview">x &lt; y</span><script
-          type="math/tex">x < y</script> we have ...
-
-This circumvents the Internet Explorer space-removal bug, while at the
-same time giving your readers a preview of the mathematics until
-MathJax has been able to typeset it.
-
-You can use CSS styles to make it easier to distinguish the preview
-from the rest of the text.  For example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-        ...
-      	styles: {
-	  ".MathJax_Preview": {
-	    color: "red",
-	    border: "1px solid",
-	    padding: "2px"
-	  }
-	},
-	...
-      });
-    </script>
-
-would cause the preview mathematics to be shown in red, with a border
-and 2px of padding between the border and the preview text.
-
-
-MATHJAX WITH MATHML:
-
-In addition to the TeX input processor, MathJax includes a MathML input
-processor, so that you can specify your mathematics using MathML rather
-than TeX, if you wish.  (The input and output processors are called "jax".)
-As with the TeX input jax, there is a pre-processor that looks for MathML
-in your web page (XHTML or HTML) and converts it to the form needed by
-MathJax.  The preprocessor is called "mml2jax.js", and the associated input
-jax is "input/MathML".  You can request these in your
-MathJax/config/MathJax.js file, or in line, as in the following example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-        extensions: ["mml2jax.js"],
-	jax: ["input/MathML","output/HTML-CSS"]
-      });
-    </script>
-
-When it is used, the mml2jax preprocessor will scan your page for <math>
-tags and insert them into the <script> tags that MathJax needs to identify
-the mathematics on the page.  This works in both HTML and XHTML pages, and
-with browsers that don't have native support for MathML.  While MathJax is
-not as fast as a native implementation of MathML, it does bring MathML to
-all major browsers.  (It is even possible to set up a GreaseMonkey-style
-script to have MathJax automatically process any MathML on any page you
-visit, so MathJax can be used to make MathML available even when the page
-author has not specifically loaded MathJax.  There are some caveats for
-this, however, so such a script is not currently being supplied.)
-
-For MathML that is handled via the pre-processor, you should not use the
-MathML named entities, but rather use the numeric entities like &#x221A; or
-unicode characters embedded in the page itself.  The reason is that the
-entities are replaced by the browser before MathJax runs, and some browsers
-report errors for unknown entities; for browsers that are not MathML-aware,
-that will cause errors to be displayed for the MathML entities.  While that
-might not occur in the browser you are using to compose your pages, it can
-happen with other browsers, so you should avoid the named entities whenever
-possible.  If you must use named entities, you may need to declare them in
-the DOCTYPE declaration by hand.
-
-
-MATHML WITH NO PREPROCESSOR:
-
-Just as there is a way to enter TeX code without a preprocessor, MathJax
-provides a means of specifying MathML without a preprocessor.  In this
-case, you enclose your complete <math> substree within a 
-<script type="math/mml">...</script> tag.  E.g.:
-
-    <script type="math/mml">
-      <math display="block">
-        <mi>x</mi><mo>=</mo><mn>1</mn>
-      </math>
-    </script>
-
-Note that the <math> tag's display attribute controls whether the node is
-typeset in-line or as a displayed equation.  The same caveats concerning
-spacing apply to MathML as to TeX, so see the section on MATHJAX WITH NO
-PREPROCESSOR above for how to deal with an Internet Explorer bug that
-requires special treatment.
-
-
-MATHML OUTPUT:
-
-In addition to the HTML-CSS output jax, MathJax provides a native-MathML
-output jax that generates MathML to display your mathematics rather than
-complicated HTML with CSS.  For browsers that support MathML, this can be
-considerably faster, plus it provides for accessibility and the ability to
-cut and paste mathematics that MathML offers.  MathML output is available
-for both TeX input and MathML input, so MathJax can act as a TeX-to-MathML
-converter right in the browser.
-
-To use the native MathML output jax, specify "output/NativeMML" rather than
-"output/HTML-CSS" in the jax array of your MathJax.Hub.Config() call (or in
-MathJax/config/MathJax.js).  For example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-        extensions: ["tex2jax.js"],
-	jax: ["input/TeX","output/NativeMML"]
-      });
-    </script>
-
-Note that this will only work for those browsers that support MathML
-natively, so you should be careful to know your audience if you use this
-output jax.  Also, note that the MathML output jax produces MathML3.0, not
-2.0, and so some browsers may not be able to handle all the constructs that
-MathJax will produce.  Although it is slower, the HTML-CSS output jax is
-more reliable than the NativeMML output jax, at least from a cross-browser
-standpoint, particularly when the TeX input jax is used.
-
-Because of the speed of the native MathML rendering, some users may prefer
-to use that than the HTML-CSS output jax, but you may not want to prevent
-those who don't have native MathML support from viewing your pages, so you
-may want to select between NativeMML and HTML-CSS automatically, depending
-on the capabilities of the browser.  MathJax provides a configuration file
-that does just that.  To use it, include "MMLorHTML.js" in the config array
-of your MathJax.Hub.Config() call.  If you use this, be sure NOT to include
-an output jax in your jax array, as MMLorHTML.js will fill that in for you.
-For example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-	config: ["MMLorHTML.js"],
-        extensions: ["tex2jax.js"],
-	jax: ["input/TeX"]
-      });
-    </script>
-
-In the case where both NativeMML and HTML-CSS are supported, the MMLorHTML
-configuration file will choose HTML-CSS, even though it is slower; this is
-because it is more reliable, since MathJax produces MathML3.0 and not all
-browsers can display that.  This is configurable, however, and you may want
-to change the preference to NativeMML instead, especially if your input
-language is MathML already.  This can be done using the MMLorHTML section
-of your configuration:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-	config: ["MMLorHTML.js"],
-        extensions: ["tex2jax.js"],
-	jax: ["input/TeX"],
-	MMLorHTML: {prefer: "MML"}
-      });
-    </script>
-
-Note, however, that not all users will have your own preferences about what
-"looks best" or "performs best", so while you may value speed above all
-else, others may value readability or reliability more.  Also, remember
-that browsers other than the one you are using (or the same browser on
-other operating systems) may not support native MathML as well as yours
-does.  For example, Opera does handle simple MathML fairly well, but breaks
-down quickly for some more complex equations, and while you may have
-Firefox all set up for MathML, others may not have installed the needed
-fonts, and will be unhappy to get a warning dialog box whenever they visit
-your web page.  So think carefully about the assumptions you are making on
-behalf of your readers.  At some point, MathJax may include a control panel
-that will allow users to select preferences on their own, but that is not
-available currently.
-
-
-CONVERSION FROM JSMATH:
-
-If you are currently using jsMath and would like to switch to MathJax, the
-transition should be fairly straight-forward.  If you are using jsMath's
-easy/load.js, then you should simply switch the line that loads
-jsMath/easy/load.js to
-
-	<script src="path-to-mathjax/MathJax/MathJax.js"></script>
-
-where "path-to-mathjax" is the path to the MathJax folder on your server.
-This uses the MathJax/config/MathJax.js file to configure MathJax, similar
-to easy/load.js, and you can read the comments in that file for details.
-Be sure to include "tex2jax.js" in your extensions array if you want the
-TeX preprocessor to run (comparable to the tex2math plugin for jsMath).
-
-If you did not use the tex2math plugin for jsMath and instead inserted your
-own <span class="math">...</span> and <div class="math">...</div> tags with
-class="math", then you need to do a little more work for MathJax.  These
-need to be replaced by <script type="math/tex">...</script> and <script
-type="math/tex; mode=display">...</script> tags.  See also the section
-MATHJAX WITHOUT A PREPROCESSOR above for some caveats concerning an
-Internet Explorer bug that you will need to be aware of.
-
-If you are using a preprocessor of your own to write your HTML files, it
-should be a simple matter of changing over the inserted tags to the ones
-that MathJax needs.  If you have existing HTML pages, however, and don't
-want to (or can't) reprocess them, then you may want to use the jsMath2jax
-preprocessor, which will first convert the span and div tags to script tags
-before running MathJax.  To do so, include "jsMath2jax.js" in your
-extensions array, as in the following example:
-
-    <script type="text/javascript" src="/MathJax/MathJax.js">
-      MathJax.Hub.Config({
-        extensions: ["jsMath2jax.js"],
-	jax: ["input/TeX", "output/HTML-CSS"]
-      });
-    </script>
-
-You should remove all the jsMath calls, like jsMath.Process(), or script
-tags that load jsMath extensions.  Only the single script tag that loads
-MathJax should be needed.
-
-If you have created pages with dynamic mathematics that is processed by
-jsMath on the fly, that is handled somewhat differently with MathJax.
-MathJax has a richer API for dealing with mathematics on the page, but the
-documentation is not yet ready.  There have been discussions in the MathJax
-on-line forums that deal with this topic, so your best bet right now is to
-read them.
-
-
-COMMUNITY:
-
-The main MathJax website is www.mathjax.org, and it includes announcements
-and other important information.  MathJax also has a SourceForge site at
-http://sourceforge.net/projects/mathjax/ that includes the download site
-for the MathJax distribution, the bug-tracker for reporting bugs, and
-several user forums for asking questions and getting assistance:
-
-    Bug tracker:      http://sourceforge.net/tracker/?group_id=261188&atid=1240827
-    MathJax Help:     http://sourceforge.net/projects/mathjax/forums/forum/948701
-    Open Discussion:  http://sourceforge.net/projects/mathjax/forums/forum/948700
-
-Before reporting a bug, please check that it has not already been reported.
-Also, please use the bug tracker for reporting bugs rather than the help
-forum.

lib/gollum/frontend/public/javascript/MathJax/config/MMLorHTML.js

@@ -1,63 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/MMLorHTML.js
- *  
- *  Chooses between the NativeMML and HTML-CSS output jax depending
- *  on the capabilities of the browser and configuration settings
- *  of the page.
- *  
- *  This file should be added to the config array when configuring
- *  MathJax.  Note that if you include this, you should NOT include
- *  an output jax in the jax array (it will be added for you by
- *  this file).
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-(function (HUB) {
-  var CONFIG = MathJax.Hub.Insert({prefer: "HTML"},(MathJax.Hub.config.MMLorHTML||{}));
-
-  var MINBROWSERVERSION = {
-    Firefox: 3.0,
-    Opera: 9.52,
-    MSIE: 6.0,
-    Chrome: 0.3,
-    Safari: 2.0,
-    Konqueror: 4.0
-  };
-
-  var canUseHTML = (HUB.Browser.version === "0.0" ||
-                    HUB.Browser.versionAtLeast(MINBROWSERVERSION[HUB.Browser]||0.0));
-
-  var MathPlayer; try {new ActiveXObject("MathPlayer.Factory.1"); MathPlayer = true} catch(err) {MathPlayer = false};
-
-  var canUseMML = (HUB.Browser.isFirefox && HUB.Browser.versionAtLeast("1.5")) ||
-                  (HUB.Browser.isMSIE && MathPlayer) ||
-                  (HUB.Browser.isOpera && HUB.Browser.versionAtLeast("9.52"));
-  if (canUseHTML || canUseMML) {
-    if (canUseMML && (CONFIG.prefer === "MML" || !canUseHTML))
-      {HUB.config.jax.push("output/NativeMML")} else {HUB.config.jax.push("output/HTML-CSS")}
-  } else {
-    HUB.PreProcess.disabled = true;
-    HUB.prepareScripts.disabled = true;
-    MathJax.Message.Set("Your browser does not support MathJax",null,4000);
-    HUB.Startup.signal.Post("MathJax not supported");
-  }
-
-})(MathJax.Hub);
-
-MathJax.Ajax.loadComplete("[MathJax]/config/MMLorHTML.js");

lib/gollum/frontend/public/javascript/MathJax/config/MathJax.js

@@ -1,351 +0,0 @@
-/*************************************************************
- *
- *  MathJax/config/MathJax.js
- *
- *  This configuration file is loaded when there is no explicit
- *  configuration script in the <script> tag that loads MathJax.js
- *
- *  Use it to customize the MathJax settings.  See comments below.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009-10 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Config({
-
-  //
-  //  A comma-separated list of configuration files to load
-  //  when MathJax starts up.  E.g., to define local macros, etc.
-  //  teh default directory is the MathJax/config directory.
-  //  
-  //  Example:    config: ["local/local.js"],
-  //  Example:    config: ["local/local.js","MMLtoHTML.js"],
-  //
-  config: [],
-  
-  //
-  //  A comma-separated list of CSS stylesheet files to be loaded
-  //  when MathJax starts up.  The default directory is the
-  //  MathJax/config directory.
-  // 
-  //  Example:    styleSheets: ["MathJax.css"],
-  //
-  styleSheets: [],
-  
-  //
-  //  Styles to be defined dynamically at startup time.
-  //  
-  //  Example:
-  //      styles: {
-  //        ".MathJax .merror": {
-  //          color: "blue",
-  //          "background-color": "green"
-  //        }
-  //      },
-  //
-  styles: {},
-  
-  //
-  //  A comma-separated list of input and output jax to initialize at startup.
-  //  Their main code is only loaded when they are actually used, so it is not
-  //  inefficient to include jax that are not actually used on the page.  These
-  //  are found in the MathJax/jax directory.
-  //  
-  jax: ["input/TeX","output/HTML-CSS"],
-  
-  //
-  //  A comma-separated list of extensions to load at startup.  The default
-  //  directory is MathJax/extensions.
-  //  
-  //  Example:    extensions: ["tex2jax.js","TeX/AMSmath.js","TeX/AMSsymbols.js"],
-  //
-  extensions: ["tex2jax.js"],
-  
-  //
-  //  Comma-separated lists of .js and .css files to load at startup that depend
-  //  on the browser being used.  The default directory is MathJax/config/browsers.
-  //
-  browser: {
-    MSIE: [],
-    Chrome: [],
-    Safari: [],
-    Firefox: [],
-    Opera: []
-  },
-  
-  //
-  //  Patterns to remove from before and after math script tags.  If you are not
-  //  using one of the preprocessors (e.g., tex2jax), you need to insert something
-  //  etra into your HTML file in order to avoid a bug in Internet Explorer (IE
-  //  removes spaces from the DOM that it things are redundent, and since a SCRIPT
-  //  tag usually doesn't add content to the page, if there is a space before and after
-  //  a MathJax SCRIPT tag, IE will remove the first space.  When MathJax inserts
-  //  the typeset mathematics, this means there will be no space before it and the
-  //  preceeding text.  In order to avoid this, you should include some "guard characters"
-  //  before or after the math SCRIPT tag; define the patterns you want to use below.
-  //  Note that these are actually regular expressions, so you will need to quote
-  //  special characters.  If both are defined, both must be present in order to be
-  //  removed.  See also the preRemoveClass comments below.
-  //  
-  //  Example:
-  //      preJax: "\\\\",  // makes a double backslash the preJax text
-  //    or
-  //      preJax:  "\[\[", // jax scripts must be enclosed in double brackets
-  //      postJax: "\]\]",
-  //
-  preJax: null,
-  postJax: null,
-  
-  //
-  //  The CSS class for a math preview to be removed preceeding a MathJax SCRIPT tag.
-  //  This allows you to include a math preview in a form that will be displayed prior
-  //  to MathJax loading performing its typesetting.  It also avoids the Internet Explorer
-  //  space-removal bug, and can be used in place of preJax and postJax if that is more
-  //  convenient.  For example
-  //  
-  //      <span class="MathJax_Preview">[math]</span><script type="math/tex">...</script>
-  //
-  //  would display "[math]" in place of the math until MathJax is able to typeset it.
-  //
-  preRemoveClass: "MathJax_Preview",
-  
-  //
-  //  This value controls whether the "Processing Math: nn%" message are displayed
-  //  in the lower left-hand corner.  Set to "false" to prevent those messages (though
-  //  file loading and other messages will still be shown).
-  //
-  showProcessingMessages: true,
-  
-  //
-  //  Normally MathJax will perform its starup commands (loading of
-  //  configuration, styles, jax, and so on) as soon as it can.  If you
-  //  expect to be doing additional configuration on the page, however, you
-  //  may want to have it wait until the page's onload hander is called.  If so,
-  //  set this to "onload".
-  //
-  delayStartupUntil: "none",
-
-  //
-  //  Normally MathJax will typeset the mathematics on the page as soon as
-  //  the page is loaded.  If you want to delay that process, in which case
-  //  you will need to call MathJax.Hub.Typeset() yourself by hand, set
-  //  this value to true.
-  //
-  skipStartupTypeset: false,
-  
-  //============================================================================
-  //
-  //  These parameters control the tex2jax preprocessor (when you have included
-  //  "tex2jax.js" in the extensions list above).
-  //
-  tex2jax: {
-
-    //
-    //  The Id of the element to be processed (defaults to full document)
-    //
-    element: null,
-
-    //
-    //  The delimiters that surround in-line math expressions.  The first in each
-    //  pair is the initial delimiter and the second is the terminal delimiter.
-    //  Comment out any that you don't want, but be sure there is no extra
-    //  comma at the end of the last item in the list -- some browsers won't
-    //  be able to handle that.
-    //
-    inlineMath: [
-//    ['$','$'],      // uncomment this for standard TeX math delimiters
-      ['\\(','\\)']
-    ],
-
-    //
-    //  The delimiters that surround displayed math expressions.  The first in each
-    //  pair is the initial delimiter and the second is the terminal delimiter.
-    //  Comment out any that you don't want, but be sure there is no extra
-    //  comma at the end of the last item in the list -- some browsers won't
-    //  be able to handle that.
-    //
-    displayMath: [
-      ['$$','$$'],
-      ['\\[','\\]']
-    ],
-
-    //
-    //  Set to "true" to allow \$ to produce a dollar without starting in-line
-    //  math mode.  If you uncomment the ['$','$'] line above, you should change
-    //  this to true so that you can insert plain dollar signs into your documents
-    //
-    processEscapes: false,
-
-    //
-    //  Controls whether tex2jax processes LaTeX environments outside of math
-    //  mode.  Set to "false" to prevent processing of environments except within
-    //  math mode.
-    //
-    processEnvironments: true,
-
-    //
-    //  Controls whether tex2jax inserts MathJax_Preview spans so that the TeX
-    //  code is visible until it is processed by MathJax.  Set to "false" to prevent
-    //  the previews from being inserted (the math will simply disappear until it is
-    //  typeset).
-    //  
-    previewTeX: true
-    
-  },
-  
-  //============================================================================
-  //
-  //  These parameters control the jsMath2jax preprocessor (when you have included
-  //  "jsMath2jax.js" in the extensions list above).
-  //
-  jsMath2jax: {
-    //
-    //  Controls whether jsMath2tex inserts MathJax_Preview elements so that
-    //  the TeX code is visible until it is processed by MathJax.  Set to "false"
-    //  to prevent previews from being inserted (the math will simply disappear
-    //  until it is typeset).
-    //
-    previewTeX: true
-  },
-
-  //============================================================================
-  //
-  //  These parameters control the TeX input jax.
-  //
-  TeX: {
-
-    //
-    //  This specifies the side on which \tag{} macros will place the tags.
-    //  Set to "left" to place on the left-hand side.
-    //
-    TagSide: "right",
-    
-    //
-    //  This is the amound of indentation (from right or left) for the tags.
-    //
-    TagIndent: ".8em",
-    
-    //
-    //  This is the width to use for the multline environment
-    //
-    MultLineWidth: "85%"
-  },
-
-  //============================================================================
-  //
-  //  These parameters control the MathML inupt jax.
-  //
-  MathML: {
-    //
-    //  This specifies whether to use TeX spacing or MathML spacing when the
-    //  HTML-CSS output jax is used.
-    //
-    useMathMLspacing: false
-  },
-  
-  //============================================================================
-  //
-  //  These parameters control the HTML-CSS output jax.
-  //
-  "HTML-CSS": {
-    
-    //
-    //  This controls the global scaling of mathematics as compared to the 
-    //  surrounding text.  Values between 100 and 133 are usually good choices.
-    //
-    scale: 100,
-    
-    //
-    //  This is a list of the fonts available to MathJax in the
-    //  MathJax/Fonts/HTML-CSS directory.  If you don't want MathJax
-    //  to use one of these fonts (when available on the user's computer),
-    //  remove it from the list.  Use an empty list to force the use of
-    //  web fonts (or image fonts).
-    //
-    availableFonts: ["STIX","TeX"],
-    
-    //
-    //  This is the preferred font to use when more than one of those
-    //  listed above is available.
-    //
-    preferredFont: "TeX",
-    
-    //
-    //  This is the web-based font to use when none of the fonts listed
-    //  above are available on the user's computer.  Note that currently
-    //  only the TeX font is available in a web-based form.  Set this to
-    //  
-    //      webFont: null,
-    //
-    //  if you want to prevent the use of web-based fonts.
-    //
-    webFont: "TeX",
-    
-    //
-    //  This is the font to use for image fallback mode (when none of the
-    //  fonts listed above are available and the browser doesn't support
-    //  web-fonts via the @font-face CSS directive).  Note that currently
-    //  only the TeX font is available as an image font.  Set this to
-    //
-    //      imageFont: null,
-    //  
-    //  if you want to prevent the use of image fonts (e.g., you have not
-    //  installed the image fonts on your server).  In this case, only
-    //  browsers that support web-based fonts will be able to view your pages
-    //  without having the fonts installed on the client computer.  The browsers
-    //  that support web-based fonts include: IE6 and later, Chrome, Safari3.1
-    //  and above, Firefox3.5 and later, and Opera10 and later.  Note that
-    //  Firefox3.0 is NOT on this list, so without image fonts, FF3.0 users
-    //  will be required to to download and install either the STIX fonts or the
-    //  MathJax TeX fonts.
-    //
-    imageFont: "TeX",
-
-    //
-    //  This allows you to define or modify the styles used to display
-    //  various math elements created by MathJax.
-    //  
-    //  Example:
-    //      styles: {
-    //        ".MathJax_Display": {
-    //          "text-align": "left",        // left aligned displayed math
-    //          "margin-left": "3em",        //   with 3em indentation
-    //        },
-    //        ".MathJax_Preview": {
-    //          "font-size": "80%",          // preview uses a smaller font
-    //          color: "red"                 //    and is in red
-    //        }
-    //      }
-    //
-    styles: {}
-  },
-  
-  //============================================================================
-  //
-  //  These parameters control the MMLorHTML configuration file.
-  //  NOTE:  if you add MMLorHTML.js to the config array above,
-  //  you must REMOVE the output jax from the jax array.
-  //
-  MMLorHTML: {
-    //
-    //  The output jax that is to be preferred when both are possible
-    //  (set to "MML" for native MathML, "HTML" for MathJax's HTML-CSS output jax).
-    //
-    prefer: "HTML"
-  }
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/config/MathJax.js");

lib/gollum/frontend/public/javascript/MathJax/config/local/local.js

@@ -1,37 +0,0 @@
-/*************************************************************
- *
- *  MathJax/config/local/local.js
- *  
- *  Include changes and configuration local to your installation
- *  in this file.  For example, common macros can be defined here
- *  (see below).  To use this file, add "local/local.js" to the
- *  config array in MathJax.js or your MathJax.Hub.Config() call.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var TEX = MathJax.InputJax.TeX;
-
-  // place macros here.  E.g.:
-  //   TEX.Macro("R","{\\bf R}");
-  //   TEX.Macro("op","\\mathop{\\rm #1}",1); // a macro with 1 parameter
-  
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/config/local/local.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/AMSmath.js

@@ -1,376 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/AMSmath.js
- *
- *  Implements AMS math environments and macros.
- *  
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  var TEX = MathJax.InputJax.TeX;
-  var TEXDEF = TEX.Definitions;
-  var STACKITEM = TEX.Stack.Item;
-  
-  var COLS = function (W) {return W.join("em ") + "em"};
-  
-  MathJax.Hub.Insert(TEXDEF,{
-    macros: {
-      mathring:   ['Accent','2DA'],  // or 0x30A
-      
-      nobreakspace: 'Tilde',
-      negmedspace:    ['Spacer',MML.LENGTH.NEGATIVEMEDIUMMATHSPACE],
-      negthickspace:  ['Spacer',MML.LENGTH.NEGATIVETHICKMATHSPACE],
-      
-      intI:       ['Macro','\\mathchoice{\\!}{}{}{}\\!\\!\\int'],
-//    iint:       ['MultiIntegral','\\int\\intI'],          // now in core TeX input jax
-//    iiint:      ['MultiIntegral','\\int\\intI\\intI'],    // now in core TeX input jax
-      iiiint:     ['MultiIntegral','\\int\\intI\\intI\\intI'],
-      idotsint:   ['MultiIntegral','\\int\\cdots\\int'],
-      
-      dddot:      ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}}',1],
-      ddddot:     ['Macro','\\mathop{#1}\\limits^{\\textstyle \\mathord{.}\\mathord{.}\\mathord{.}\\mathord{.}}',1],
-      
-      sideset:    ['Macro','\\mathop{\\mathop{\\rlap{\\phantom{#3}}}\\nolimits#1\\!\\mathop{#3}\\nolimits#2}',3],
-      
-      boxed:      ['Macro','\\fbox{$\\displaystyle{#1}$}',1],
-      
-      tag:         'HandleTag',
-      notag:       'HandleNoTag',
-      
-      substack:   ['Macro','\\begin{subarray}{c}#1\\end{subarray}',1],
-      
-      injlim:     ['Macro','\\mathop{\\rm inj\\,lim}'],
-      projlim:    ['Macro','\\mathop{\\rm proj\\,lim}'],
-      varliminf:  ['Macro','\\mathop{\\underline{\\rm lim}}'],
-      varlimsup:  ['Macro','\\mathop{\\overline{\\rm lim}}'],
-      varinjlim:  ['Macro','\\mathop{\\underrightarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
-      varprojlim: ['Macro','\\mathop{\\underleftarrow{\\rm lim\\Rule{-1pt}{0pt}{1pt}}\\Rule{0pt}{0pt}{.45em}}'],
-      
-      DeclareMathOperator: 'HandleDeclareOp',
-      operatorname:        'HandleOperatorName',
-      
-      genfrac:     'Genfrac',
-      frac:       ['Genfrac',"","","",""],
-      tfrac:      ['Genfrac',"","","",1],
-      dfrac:      ['Genfrac',"","","",0],
-      binom:      ['Genfrac',"(",")","0em",""],
-      tbinom:     ['Genfrac',"(",")","0em",1],
-      dbinom:     ['Genfrac',"(",")","0em",0],
-      
-      cfrac:       'CFrac',
-      
-      shoveleft:  ['HandleShove',MML.ALIGN.LEFT],
-      shoveright: ['HandleShove',MML.ALIGN.RIGHT],
-      
-      xrightarrow: ['xArrow',0x2192,5,6],
-      xleftarrow:  ['xArrow',0x2190,7,3]
-    },
-    
-    environment: {
-      align:         ['AMSarray',null,true,true,  'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
-      'align*':      ['AMSarray',null,false,true, 'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18])],
-      multline:      ['Multline',null,true],
-      'multline*':   ['Multline',null,false],
-      split:         ['AMSarray',null,false,false,'rl',COLS([5/18])],
-      gather:        ['AMSarray',null,true,true,  'c'],
-      'gather*':     ['AMSarray',null,false,true, 'c'],
-      
-      alignat:       ['AlignAt',null,true,true],
-      'alignat*':    ['AlignAt',null,false,true],
-      alignedat:     ['AlignAt',null,false,false],
-
-      aligned:       ['Array',null,null,null,'rlrlrlrlrlrl',COLS([5/18,2,5/18,2,5/18,2,5/18,2,5/18,2,5/18]),".5em",'D'],
-      gathered:      ['Array',null,null,null,'c',null,".5em",'D'],
-
-      subarray:      ['Array',null,null,null,null,COLS([0,0,0,0]),"0.1em",'S',1],
-      smallmatrix:   ['Array',null,null,null,'c',COLS([1/3]),".2em",'S',1]
-    },
-    
-    delimiter: {
-      '\\lvert':     ['2223',{texClass:MML.TEXCLASS.OPEN}],
-      '\\rvert':     ['2223',{texClass:MML.TEXCLASS.CLOSE}],
-      '\\lVert':     ['2225',{texClass:MML.TEXCLASS.OPEN}],
-      '\\rVert':     ['2225',{texClass:MML.TEXCLASS.CLOSE}]
-    }
-  });
-    
-
-  TEX.Parse.Augment({
-
-    /*
-     *  Add the tag to the environment to be added to the table row later
-     */
-    HandleTag: function (name) {
-      var arg = this.trimSpaces(this.GetArgument(name));
-      if (arg === "*") {arg = this.GetArgument(name)} else {arg = "("+arg+")"}
-      if (this.stack.global.notag)
-        {TEX.Error(name+" not allowed in "+this.stack.global.notag+" environment")}
-      if (this.stack.global.tag) {TEX.Error("Multiple "+name)}
-      this.stack.global.tag = MML.mtd.apply(MML,this.InternalMath(arg));
-    },
-    HandleNoTag: function (name) {
-      if (this.stack.global.tag) {delete this.stack.global.tag}
-    },
-    
-    /*
-     *  Handle \DeclareMathOperator
-     */
-    HandleDeclareOp: function (name) {
-      var limits = "";
-      var cs = this.trimSpaces(this.GetArgument(name));
-      if (cs == "*") {
-        limits = "\\limits";
-        cs = this.trimSpaces(this.GetArgument(name));
-      }
-      if (cs.charAt(0) == "\\") {cs = cs.substr(1)}
-      var op = this.GetArgument(name);
-      op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
-      TEX.Definitions.macros[cs] = ['Macro','\\mathop{\\rm '+op+'}'+limits];
-    },
-    
-    HandleOperatorName: function (name) {
-      var limits = "\\nolimits";
-      var op = this.trimSpaces(this.GetArgument(name));
-      if (op == "*") {
-        limits = "\\limits";
-        op = this.trimSpaces(this.GetArgument(name));
-      }
-      op = op.replace(/\*/g,'\\text{*}').replace(/-/g,'\\text{-}');
-      this.string = '\\mathop{\\rm '+op+'}'+limits+" "+this.string.slice(this.i);
-      this.i = 0;
-    },
-    
-    /*
-     *  Record presence of \shoveleft and \shoveright
-     */
-    HandleShove: function (name,shove) {
-      var top = this.stack.Top();
-      if (top.type !== "multline" || top.data.length) {TEX.Error(name+" must come at the beginning of the line")}
-      top.data.shove = shove;
-    },
-    
-    /*
-     *  Handle \cfrac
-     */
-    CFrac: function (name) {
-      var lr  = this.trimSpaces(this.GetBrackets(name)),
-          num = this.GetArgument(name),
-          den = this.GetArgument(name);
-      var frac = MML.mfrac(TEX.Parse('\\strut\\textstyle{'+num+'}',this.stack.env).mml(),
-                           TEX.Parse('\\strut\\textstyle{'+den+'}',this.stack.env).mml());
-      lr = ({l:MML.ALIGN.LEFT, r:MML.ALIGN.RIGHT,"":""})[lr];
-      if (lr == null) {TEX.Error("Illegal alignment specified in "+name)}
-      if (lr) {frac.numalign = frac.denomalign = lr}
-      this.Push(frac);
-    },
-    
-    /*
-     *  Implement AMS generalized fraction
-     */
-    Genfrac: function (name,left,right,thick,style) {
-      if (left  == null) {left  = this.GetDelimiterArg(name)} else {left  = this.convertDelimiter(left)}
-      if (right == null) {right = this.GetDelimiterArg(name)} else {right = this.convertDelimiter(right)}
-      if (thick == null) {thick = this.GetArgument(name)}
-      if (style == null) {style = this.trimSpaces(this.GetArgument(name))}
-      var num = this.ParseArg(name);
-      var den = this.ParseArg(name);
-      var frac = MML.mfrac(num,den);
-      if (thick !== "") {frac.linethickness = thick}
-      if (left || right) {frac = MML.mfenced(frac).With({open: left, close: right})}
-      if (style !== "") {
-        var STYLE = (["D","T","S","SS"])[style];
-        if (STYLE == null) {TEX.Error("Bad math style for "+name)}
-        frac = MML.mstyle(frac);
-        if (STYLE === "D") {frac.displaystyle = true; frac.scriptlevel = 0}
-          else {frac.displaystyle = false; frac.scriptlevel = style - 1}
-      }
-
-      this.Push(frac);
-    },
-
-    /*
-     *  Implements multline environment (mostly handled through STACKITEM below)
-     */
-    Multline: function (begin,numbered) {
-      this.Push(begin);
-      return STACKITEM.multline().With({
-        arraydef: {
-          displaystyle: true,
-          rowspacing: ".5em",
-          width: TEX.config.MultLineWidth, columnwidth:"100%",
-          side: TEX.config.TagSide,
-          minlabelspacing: TEX.config.TagIndent
-        }
-      });
-    },
-
-    /*
-     *  Handle AMS aligned environments
-     */
-    AMSarray: function (begin,numbered,taggable,align,spacing) {
-      this.Push(begin);
-      align = align.replace(/[^clr]/g,'').split('').join(' ');
-      align = align.replace(/l/g,'left').replace(/r/g,'right').replace(/c/g,'center');
-      return STACKITEM.AMSarray(begin.name,numbered,taggable,this.stack).With({
-        arraydef: {
-          displaystyle: true,
-          rowspacing: ".5em",
-          columnalign: align,
-          columnspacing: (spacing||"1em"),
-          rowspacing: "3pt",
-          side: TEX.config.TagSide,
-          minlabelspacing: TEX.config.TagIndent
-        }
-      });
-    },
-    
-    AlignAt: function (begin,numbered,taggable) {
-      var n = this.GetArgument("\\begin{"+begin.name+"}");
-      if (n.match(/[^0-9]/)) {TEX.Error("Argument to \\begin{"+begin.name+"} must me a positive integer")}
-      align = ""; spacing = [];
-      while (n > 0) {align += "rl"; spacing.push("0em 0em"); n--}
-      spacing = spacing.join(" ");
-      if (taggable) {return this.AMSarray(begin,numbered,taggable,align,spacing)}
-      return this.Array(begin,null,null,align,spacing,".5em",'D');
-    },
-    
-    /*
-     *  Handle multiple integrals (make a mathop if followed by limits)
-     */
-    MultiIntegral: function (name,integral) {
-      var next = this.GetNext();
-      if (next === "\\") {
-        var i = this.i; next = this.GetArgument(name); this.i = i;
-        if (next === "\\limits") {
-          if (name === "\\idotsint") {integral = "\\!\\!\\mathop{\\,\\,"+integral+"}"}
-                           else {integral = "\\!\\!\\!\\mathop{\\,\\,\\,"+integral+"}"}
-        }
-      }
-      this.string = integral + " " + this.string.slice(this.i);
-      this.i = 0;
-    },
-    
-    xArrow: function (name,chr,l,r) {
-      var def = {width: "+"+(l+r)+"mu", lspace: l+"mu"};
-      var bot = this.GetBrackets(name),
-          top = this.ParseArg(name);
-      var arrow = MML.mo(MML.chars(String.fromCharCode(chr))).With({
-        stretchy: true, texClass: MML.TEXCLASS.REL
-      });
-      var mml = MML.munderover(arrow);
-      mml.SetData(mml.over,MML.mpadded(top).With(def).With({voffset:".15em"}));
-      if (bot) {
-        bot = TEX.Parse(bot,this.stack.env).mml()
-        mml.SetData(mml.under,MML.mpadded(bot).With(def).With({voffset:"-.24em"}));
-      }
-      this.Push(mml);
-    },
-    
-    /*
-     *  Get a delimiter or empty argument
-     */
-    GetDelimiterArg: function (name) {
-      var c = this.trimSpaces(this.GetArgument(name));
-      if (c == "") {return null}
-      if (!TEXDEF.delimiter[c]) {TEX.Error("Missing or unrecognized delimiter for "+name)}
-      return this.convertDelimiter(c);
-    }
-  });
-  
-  /*
-   *  Implement multline environment via a STACKITEM
-   */
-  STACKITEM.multline = STACKITEM.array.Subclass({
-    type: "multline",
-    EndEntry: function () {
-      var mtd = MML.mtd.apply(MML,this.data);
-      if (this.data.shove) {mtd.columnalign = this.data.shove}
-      this.row.push(mtd);
-      this.data = [];
-    },
-    EndRow: function () {
-      if (this.row.length != 1) {TEX.Error("multline rows must have exactly one column")}
-      this.table.push(this.row); this.row = [];
-    },
-    EndTable: function () {
-      this.SUPER(arguments).EndTable.call(this);
-      if (this.table.length) {
-        var m = this.table.length-1, i;
-        if (!this.table[0][0].columnalign) {this.table[0][0].columnalign = MML.ALIGN.LEFT}
-        if (!this.table[m][0].columnalign) {this.table[m][0].columnalign = MML.ALIGN.RIGHT}
-        var mtr = MML.mtr;
-        if (this.global.tag) {
-          this.table[0] = [this.global.tag].concat(this.table[0]);
-          delete this.global.tag; mtr = MML.mlabeledtr;
-        }
-        this.table[0] = mtr.apply(MML,this.table[0]);
-        for (i = 1, m = this.table.length; i < m; i++)
-          {this.table[i] = MML.mtr.apply(MML,this.table[i])}
-      }
-    }
-  });
-  
-  STACKITEM.AMSarray = STACKITEM.array.Subclass({
-    type: "AMSarray",
-    Init: function (name,numbered,taggable,stack) {
-      this.SUPER(arguments).Init.apply(this);
-      this.numbered = numbered;
-      this.save_notag = stack.global.notag;
-      stack.global.notag = (taggable ? null : name);
-    },
-    EndRow: function () {
-      var mtr = MML.mtr;
-      if (this.global.tag) {
-        this.row = [this.global.tag].concat(this.row);
-        mtr = MML.mlabeledtr;
-        delete this.global.tag;
-      }
-      this.table.push(mtr.apply(MML,this.row)); this.row = [];
-    },
-    EndTable: function () {
-      this.SUPER(arguments).EndTable.call(this);
-      this.global.notag = this.save_notag;
-    }
-  });
-  
-  //
-  //  Look for \tag on a formula and make an mtable to include it
-  //
-  STACKITEM.start.Augment({
-    oldCheckItem: STACKITEM.start.prototype.checkItem,
-    checkItem: function (item) {
-      if (item.type === "stop") {
-        var mml = this.mmlData();
-        if (this.global.tag) {
-          mml = MML.mtable(MML.mlabeledtr(this.global.tag,MML.mtd(mml)));
-          mml.side = TEX.config.TagSide;
-          mml.minlabelspacing = TEX.config.TagIndent;
-          delete this.global.tag;
-        }
-        return STACKITEM.mml(mml);
-      }
-      return this.SUPER(arguments).checkItem.call(this,item);
-    }
-  });
-  
-  MathJax.Hub.Startup.signal.Post("TeX AMSmath Ready");
-  
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSmath.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/AMSsymbols.js

@@ -1,385 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/AMSsymbols.js
- *  
- *  Implements macros for accessing the AMS symbol fonts.
- *  
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  
-  MathJax.Hub.Insert(MathJax.InputJax.TeX.Definitions,{
-
-    mathchar0mi: {
-      // Lowercase Greek letters
-      digamma:                '03DD',
-      varkappa:               '03F0',
-      
-      // Uppercase Greek letters
-      varGamma:               ['0393',{mathvariant: MML.VARIANT.ITALIC}],
-      varDelta:               ['0394',{mathvariant: MML.VARIANT.ITALIC}],
-      varTheta:               ['0398',{mathvariant: MML.VARIANT.ITALIC}],
-      varLambda:              ['039B',{mathvariant: MML.VARIANT.ITALIC}],
-      varXi:                  ['039E',{mathvariant: MML.VARIANT.ITALIC}],
-      varPi:                  ['03A0',{mathvariant: MML.VARIANT.ITALIC}],
-      varSigma:               ['03A3',{mathvariant: MML.VARIANT.ITALIC}],
-      varUpsilon:             ['03A5',{mathvariant: MML.VARIANT.ITALIC}],
-      varPhi:                 ['03A6',{mathvariant: MML.VARIANT.ITALIC}],
-      varPsi:                 ['03A8',{mathvariant: MML.VARIANT.ITALIC}],
-      varOmega:               ['03A9',{mathvariant: MML.VARIANT.ITALIC}],
-
-      // Hebrew letters
-      beth:                   '2136',
-      gimel:                  '2137',
-      daleth:                 '2138',
-
-      // Miscellaneous symbols
-//    hbar:                   '0127',  // in MathJax_Main
-      backprime:              ['2035',{variantForm: true}],
-      hslash:                 ['210F',{variantForm: true}],
-      varnothing:             ['2205',{variantForm: true}],
-      blacktriangle:          '25B2',
-      triangledown:           '25BD',
-      blacktriangledown:      '25BC',
-      square:                 '25A1',
-      Box:                    '25A1',
-      blacksquare:            '25A0',
-      lozenge:                '25CA',
-      Diamond:                '25CA',
-      blacklozenge:           '29EB',
-      circledS:               ['24C8',{mathvariant: MML.VARIANT.NORMAL}],
-      bigstar:                '2605',
-//    angle:                  '2220',  // in MathJax_Main
-      sphericalangle:         '2222',
-      measuredangle:          '2221',
-      nexists:                '2204',
-      complement:             '2201',
-      mho:                    '2127',
-      eth:                    ['00F0',{mathvariant: MML.VARIANT.NORMAL}],
-      Finv:                   '2132',
-      diagup:                 '2571',
-      Game:                   '2141',
-      diagdown:               '2572',
-      Bbbk:                   ['006B',{mathvariant: MML.VARIANT.DOUBLESTRUCK}],
-      
-      yen:                    '00A5',
-      circledR:               '00AE',
-      checkmark:              '2713',
-      maltese:                '2720'
-    },
-
-    mathchar0mo: {
-      // Binary operators
-      dotplus:                '2214',
-      ltimes:                 '22C9',
-      smallsetminus:          ['2216',{variantForm: true}],
-      rtimes:                 '22CA',
-      Cap:                    '22D2',
-      doublecap:              '22D2',
-      leftthreetimes:         '22CB',
-      Cup:                    '22D3',
-      doublecup:              '22D3',
-      rightthreetimes:        '22CC',
-      barwedge:               '22BC',
-      curlywedge:             '22CF',
-      veebar:                 '22BB',
-      curlyvee:               '22CE',
-      doublebarwedge:         '2A5E',
-      boxminus:               '229F',
-      circleddash:            '229D',
-      boxtimes:               '22A0',
-      circledast:             '229B',
-      boxdot:                 '22A1',
-      circledcirc:            '229A',
-      boxplus:                '229E',
-      centerdot:              '22C5',
-      divideontimes:          '22C7',
-      intercal:               '22BA',
-
-      // Binary relations
-      leqq:                   '2266',
-      geqq:                   '2267',
-      leqslant:               '2A7D',
-      geqslant:               '2A7E',
-      eqslantless:            '2A95',
-      eqslantgtr:             '2A96',
-      lesssim:                '2272',
-      gtrsim:                 '2273',
-      lessapprox:             '2A85',
-      gtrapprox:              '2A86',
-      approxeq:               '224A',
-      lessdot:                '22D6',
-      gtrdot:                 '22D7',
-      lll:                    '22D8',
-      llless:                 '22D8',
-      ggg:                    '22D9',
-      gggtr:                  '22D9',
-      lessgtr:                '2276',
-      gtrless:                '2277',
-      lesseqgtr:              '22DA',
-      gtreqless:              '22DB',
-      lesseqqgtr:             '2A8B',
-      gtreqqless:             '2A8C',
-      doteqdot:               '2251',
-      Doteq:                  '2251',
-      eqcirc:                 '2256',
-      risingdotseq:           '2253',
-      circeq:                 '2257',
-      fallingdotseq:          '2252',
-      triangleq:              '225C',
-      backsim:                '223D',
-      thicksim:               ['223C',{variantForm: true}],
-      backsimeq:              '22CD',
-      thickapprox:            '2248',
-      subseteqq:              '2AC5',
-      supseteqq:              '2AC6',
-      Subset:                 '22D0',
-      Supset:                 '22D1',
-      sqsubset:               '228F',
-      sqsupset:               '2290',
-      preccurlyeq:            '227C',
-      succcurlyeq:            '227D',
-      curlyeqprec:            '22DE',
-      curlyeqsucc:            '22DF',
-      precsim:                '227E',
-      succsim:                '227F',
-      precapprox:             '2AB7',
-      succapprox:             '2AB8',
-      vartriangleleft:        '22B2',
-      lhd:                    '22B2',
-      vartriangleright:       '22B3',
-      rhd:                    '22B3',
-      trianglelefteq:         '22B4',
-      unlhd:                  '22B4',
-      trianglerighteq:        '22B5',
-      unrhd:                  '22B5',
-      vDash:                  '22A8',
-      Vdash:                  '22A9',
-      Vvdash:                 '22AA',
-      smallsmile:             '2323',
-      shortmid:               ['2223',{variantForm: true}],
-      smallfrown:             '2322',
-      shortparallel:          ['2225',{variantForm: true}],
-      bumpeq:                 '224F',
-      between:                '226C',
-      Bumpeq:                 '224E',
-      pitchfork:              '22D4',
-      varpropto:              '221D',
-      backepsilon:            '220D',
-      blacktriangleleft:      '25C0',
-      blacktriangleright:     '25B6',
-      therefore:              '2234',
-      because:                '2235',
-      eqsim:                  '2242',
-      vartriangle:            ['25B3',{variantForm: true}],
-      Join:                   '22C8',
-
-      // Negated relations
-      nless:                  '226E',
-      ngtr:                   '226F',
-      nleq:                   '2270',
-      ngeq:                   '2271',
-      nleqslant:              ['2A87',{variantForm: true}],
-      ngeqslant:              ['2A88',{variantForm: true}],
-      nleqq:                  ['2270',{variantForm: true}],
-      ngeqq:                  ['2271',{variantForm: true}],
-      lneq:                   '2A87',
-      gneq:                   '2A88',
-      lneqq:                  '2268',
-      gneqq:                  '2269',
-      lvertneqq:              ['2268',{variantForm: true}],
-      gvertneqq:              ['2269',{variantForm: true}],
-      lnsim:                  '22E6',
-      gnsim:                  '22E7',
-      lnapprox:               '2A89',
-      gnapprox:               '2A8A',
-      nprec:                  '2280',
-      nsucc:                  '2281',
-      npreceq:                ['22E0',{variantForm: true}],
-      nsucceq:                ['22E1',{variantForm: true}],
-      precneqq:               '2AB5',
-      succneqq:               '2AB6',
-      precnsim:               '22E8',
-      succnsim:               '22E9',
-      precnapprox:            '2AB9',
-      succnapprox:            '2ABA',
-      nsim:                   '2241',
-      ncong:                  '2246',
-      nshortmid:              ['2224',{variantForm: true}],
-      nshortparallel:         ['2226',{variantForm: true}],
-      nmid:                   '2224',
-      nparallel:              '2226',
-      nvdash:                 '22AC',
-      nvDash:                 '22AD',
-      nVdash:                 '22AE',
-      nVDash:                 '22AF',
-      ntriangleleft:          '22EA',
-      ntriangleright:         '22EB',
-      ntrianglelefteq:        '22EC',
-      ntrianglerighteq:       '22ED',
-      nsubseteq:              '2288',
-      nsupseteq:              '2289',
-      nsubseteqq:             ['2288',{variantForm: true}],
-      nsupseteqq:             ['2289',{variantForm: true}],
-      subsetneq:              '228A',
-      supsetneq:              '228B',
-      varsubsetneq:           ['228A',{variantForm: true}],
-      varsupsetneq:           ['228B',{variantForm: true}],
-      subsetneqq:             '2ACB',
-      supsetneqq:             '2ACC',
-      varsubsetneqq:          ['2ACB',{variantForm: true}],
-      varsupsetneqq:          ['2ACC',{variantForm: true}],
-
-
-      // Arrows
-      leftleftarrows:         '21C7',
-      rightrightarrows:       '21C9',
-      leftrightarrows:        '21C6',
-      rightleftarrows:        '21C4',
-      Lleftarrow:             '21DA',
-      Rrightarrow:            '21DB',
-      twoheadleftarrow:       '219E',
-      twoheadrightarrow:      '21A0',
-      leftarrowtail:          '21A2',
-      rightarrowtail:         '21A3',
-      looparrowleft:          '21AB',
-      looparrowright:         '21AC',
-      leftrightharpoons:      '21CB',
-      rightleftharpoons:      ['21CC',{variantForm: true}],
-      curvearrowleft:         '21B6',
-      curvearrowright:        '21B7',
-      circlearrowleft:        '21BA',
-      circlearrowright:       '21BB',
-      Lsh:                    '21B0',
-      Rsh:                    '21B1',
-      upuparrows:             '21C8',
-      downdownarrows:         '21CA',
-      upharpoonleft:          '21BF',
-      upharpoonright:         '21BE',
-      downharpoonleft:        '21C3',
-      restriction:            '21BE',
-      multimap:               '22B8',
-      downharpoonright:       '21C2',
-      leftrightsquigarrow:    '21AD',
-      rightsquigarrow:        '21DD',
-      leadsto:                '21DD',
-      dashrightarrow:         '21E2',
-      dashleftarrow:          '21E0',
-
-      // Negated arrows
-      nleftarrow:             '219A',
-      nrightarrow:            '219B',
-      nLeftarrow:             '21CD',
-      nRightarrow:            '21CF',
-      nleftrightarrow:        '21AE',
-      nLeftrightarrow:        '21CE'
-    },
-    
-    delimiter: {
-      // corners
-      "\\ulcorner":           '250C',
-      "\\urcorner":           '2510',
-      "\\llcorner":           '2514',
-      "\\lrcorner":           '2518'
-    },
-    
-    macros: {
-      implies:    ['Macro','\\;\\Longrightarrow\\;'],
-      impliedby:  ['Macro','\\;\\Longleftarrow\\;']
-    }
-    
-  });
-  
-  var REL = MML.mo.OPTYPES.REL;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      infix: {
-        '\u2322': REL,  // smallfrown
-        '\u2323': REL,  // smallsmile
-        '\u25B3': REL,  // vartriangle
-        '\uE006': REL,  // nshortmid
-        '\uE007': REL,  // nshortparallel
-        '\uE00C': REL,  // lvertneqq
-        '\uE00D': REL,  // gvertneqq
-        '\uE00E': REL,  // ngeqq
-        '\uE00F': REL,  // ngeqslant
-        '\uE010': REL,  // nleqslant
-        '\uE011': REL,  // nleqq
-        '\uE016': REL,  // nsubseteqq
-        '\uE017': REL,  // varsubsetneqq
-        '\uE018': REL,  // nsupseteqq
-        '\uE019': REL,  // varsupsetneqq
-        '\uE01A': REL,  // varsubsetneq
-        '\uE01B': REL,  // varsupsetneq
-        '\uE04B': REL,  // npreceq
-        '\uE04F': REL   // nsucceq
-      }
-    }
-  });
-
-  if (MathJax.Hub.Browser.isMSIE) {
-    MathJax.InputJax.TeX.Definitions.mathchar0mi.digamma  = ['03DC',{variantForm: true}];
-    MathJax.InputJax.TeX.Definitions.mathchar0mi.varkappa = ['03F0',{variantForm: true}];
-  }
-});
-
-MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
-  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
-  var TEXDEF = MathJax.InputJax.TeX.Definitions;
-  var VARIANT = HTMLCSS.FONTDATA.VARIANT;
-  if (HTMLCSS.fontInUse === "TeX") {
-    VARIANT["-TeX-variant"] = {
-      fonts: ["MathJax_AMS","MathJax_Main","MathJax_Size1"],
-      remap: {0x2268: 0xE00C, 0x2269: 0xE00D, 0x2270: 0xE011, 0x2271: 0xE00E,
-              0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2224: 0xE006, 0x2226: 0xE007,
-              0x2288: 0xE016, 0x2289: 0xE018, 0x228A: 0xE01A, 0x228B: 0xE01B,
-              0x2ACB: 0xE017, 0x2ACC: 0xE019, 0x03DC: 0xE008, 0x03F0: 0xE009}
-    };
-    if (HTMLCSS.msieIE6) {
-      MathJax.Hub.Insert(VARIANT["-TeX-variant"].remap,{
-        0x2190:[0xE2C1,"-WinIE6"], 0x2192:[0xE2C0,"-WinIE6"],
-        0x2223:[0xE2C2,"-WinIE6"], 0x2225:[0xE2C3,"-WinIE6"],
-        0x223C:[0xE2C4,"-WinIE6"], 0x25B3:[0xE2D3,"-WinIE6"]
-      });
-    }
-  }
-  if (HTMLCSS.fontInUse === "STIX") {
-    TEXDEF.mathchar0mi.varnothing = '2205';
-    TEXDEF.mathchar0mi.hslash = '210F';
-    TEXDEF.mathchar0mi.blacktriangle = '25B4';
-    TEXDEF.mathchar0mi.blacktriangledown = '25BE';
-    TEXDEF.mathchar0mi.square = '25FB';
-    TEXDEF.mathchar0mi.blacksquare = '25FC';
-    TEXDEF.mathchar0mi.vartriangle = ['25B3',{mathsize:"71%"}];
-    TEXDEF.mathchar0mi.triangledown = ['25BD',{mathsize:"71%"}];
-    TEXDEF.mathchar0mo.blacktriangleleft = '25C2';
-    TEXDEF.mathchar0mo.blacktriangleright = '25B8';
-    TEXDEF.mathchar0mo.smallsetminus = '2216';
-    MathJax.Hub.Insert(VARIANT["-STIX-variant"],{
-      remap: {0x2A87: 0xE010, 0x2A88: 0xE00F, 0x2270: 0xE011, 0x2271: 0xE00E,
-              0x22E0: 0xE04B, 0x22E1: 0xE04F, 0x2288: 0xE016, 0x2289: 0xE018}
-    });
-  }
-  
-  MathJax.Hub.Startup.signal.Post("TeX AMSsymbols Ready");
-  
-});
-
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/AMSsymbols.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/autobold.js

@@ -1,43 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/autobold.js
- *  
- *  Adds \boldsymbol around mathematics that appears in a section
- *  of an HTML page that is in bold.
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var TEX = MathJax.InputJax.TeX;
-  var oldPrefilter = TEX.prefilterMath;
-  
-  TEX.prefilterMath = function (math,displaystyle,script) {
-    var span = script.parentNode.insertBefore(document.createElement("span"),script);
-    span.visibility = "hidden";
-    span.style.fontFamily = "Times, serif";
-    span.appendChild(document.createTextNode("ABCXYZabcxyz"));
-    var W = span.offsetWidth;
-    span.style.fontWeight = "bold";
-    if (span.offsetWidth == W) {math = "\\bf {"+math+"}"}
-    span.parentNode.removeChild(span);
-    return oldPrefilter.call(TEX,math,displaystyle,script);
-  };
-  
-  MathJax.Hub.Startup.signal.Post("TeX autobold Ready");
-
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/autobold.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/boldsymbol.js

@@ -1,109 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/boldsymbol.js
- *  
- *  Implements the \boldsymbol{...} command to make bold
- *  versions of all math characters (not just variables).
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  var TEX = MathJax.InputJax.TeX;
-  var TEXDEF = TEX.Definitions;
-  
-  var BOLDVARIANT = {};
-  BOLDVARIANT[MML.VARIANT.NORMAL]    = MML.VARIANT.BOLD;
-  BOLDVARIANT[MML.VARIANT.ITALIC]    = MML.VARIANT.BOLDITALIC;
-  BOLDVARIANT[MML.VARIANT.FRAKTUR]   = MML.VARIANT.BOLDFRAKTUR;
-  BOLDVARIANT[MML.VARIANT.SCRIPT]    = MML.VARIANT.BOLDSCRIPT;
-  BOLDVARIANT[MML.VARIANT.SANSSERIF] = MML.VARIANT.BOLDSANSSERIF;
-  BOLDVARIANT["-tex-caligraphic"]    = "-tex-caligraphic-bold";
-  BOLDVARIANT["-tex-oldstyle"]       = "-tex-oldstyle-bold";
-  
-  TEXDEF.macros.boldsymbol = 'Boldsymbol';
-  
-  TEX.Parse.Augment({
-    mmlToken: function (token) {
-      if (this.stack.env.boldsymbol) {
-        var variant = token.Get("mathvariant");
-        if (variant == null) {token.mathvariant = MML.VARIANT.BOLD}
-        else {token.mathvariant = (BOLDVARIANT[variant]||variant)}
-      }
-      return token;
-    },
-    
-    Boldsymbol: function (name) {
-      var boldsymbol = this.stack.env.boldsymbol,
-          font = this.stack.env.font;
-      this.stack.env.boldsymbol = true;
-      this.stack.env.font = null;
-      var mml = this.ParseArg(name);
-      this.stack.env.font = font;
-      this.stack.env.boldsymbol = boldsymbol;
-      this.Push(mml);
-    }
-  });
-  
-});
-
-MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
-  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
-  var TEX = MathJax.InputJax.TeX;
-  var FONTS = HTMLCSS.FONTDATA.FONTS;
-  var VARIANT = HTMLCSS.FONTDATA.VARIANT;
-
-  if (HTMLCSS.fontInUse === "TeX") {
-    FONTS["MathJax_Caligraphic-bold"] = "Caligraphic/Bold/Main.js";
-
-    VARIANT["-tex-caligraphic-bold"] =
-      {fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"],
-       offsetA: 0x41, variantA: "bold-italic"};
-    VARIANT["-tex-oldstyle-bold"] =
-      {fonts:["MathJax_Caligraphic-bold","MathJax_Main-bold","MathJax_Main","MathJax_Math","MathJax_Size1"]};
-
-    if (HTMLCSS.msieCheckGreek && HTMLCSS.Font.testFont({
-      family:"MathJax_Greek", weight:"bold", style:"italic", testString: HTMLCSS.msieCheckGreek
-    })) {
-      VARIANT["bold-italic"].offsetG = 0x391; VARIANT["bold-italic"].variantG = "-Greek-Bold-Italic";
-      VARIANT["-Greek-Bold-Italic"] = {fonts:["MathJax_Greek-bold-italic"]};
-      FONTS["MathJax_Greek-bold-italic"] = "Greek/BoldItalic/Main.js";
-    }
-    
-    if (MathJax.Hub.Browser.isChrome && !MathJax.Hub.Browser.versionAtLeast("5.0")) {
-      VARIANT["-tex-caligraphic-bold"].remap = {0x54: [0xE2F0,"-WinChrome"]};
-    }
-    
-  } else if (HTMLCSS.fontInUse === "STIX") {
-    VARIANT["-tex-caligraphic-bold"] = {
-      fonts:["STIXGeneral-bold-italic","STIXNonUnicode-bold-italic","STIXNonUnicode","STIXGeneral","STIXSizeOneSym"],
-      offsetA: 0xE247, noLowerCase: 1
-    };
-    VARIANT["-tex-oldstyle-bold"] = {
-      fonts:["STIXGeneral-bold","STIXNonUnicode-bold","STIXGeneral","STIXSizeOneSym"], offsetN: 0xE263,
-      remap: {0xE264: 0xE267, 0xE265: 0xE26B, 0xE266: 0xE26F, 0xE267: 0xE273,
-              0xE268: 0xE277, 0xE269: 0xE27B, 0xE26A: 0xE27F, 0xE26B: 0xE283,
-              0xE26C: 0xE287}
-    };
-  }
-  
-  MathJax.Hub.Startup.signal.Post("TeX boldsymbol Ready");
-
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/boldsymbol.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/mathchoice.js

@@ -1,65 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/mathchoice.js
- *  
- *  Implements the \mathchoice macro (rarely used)
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  var TEX = MathJax.InputJax.TeX;
-  var TEXDEF = TEX.Definitions;
-  
-  TEXDEF.macros.mathchoice = 'MathChoice';
-
-  TEX.Parse.Augment({
-
-    MathChoice: function (name) {
-      var D  = this.ParseArg(name),
-          T  = this.ParseArg(name),
-          S  = this.ParseArg(name),
-          SS = this.ParseArg(name);
-      this.Push(MML.TeXmathchoice(D,T,S,SS));
-    }
-
-  });
-  
-  MML.TeXmathchoice = MML.mbase.Subclass({
-    type: "TeXmathchoice",
-    choice: function () {
-      var values = this.getValues("displaystyle","scriptlevel");
-      if (values.scriptlevel > 0) {return Math.min(3,values.scriptlevel + 1)}
-      return (values.displaystyle ? 0 : 1);
-    },
-    setTeXclass: function (prev) {return this.Core().setTeXclass(prev)},
-    isSpacelike: function () {return this.Core().isSpacelike()},
-    isEmbellished: function () {return this.Core().isEmbellished()},
-    Core: function () {return this.data[this.choice()]},
-    toHTML: function (span) {
-      span = this.HTMLcreateSpan(span);
-      span.bbox = this.Core().toHTML(span).bbox;
-      return span;
-    }
-  });
-  
-  MathJax.Hub.Startup.signal.Post("TeX mathchoice Ready");
-  
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/mathchoice.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/newcommand.js

@@ -1,185 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/newcommand.js
- *  
- *  Implements the \newcommand, \newenvironment and \def
- *  macros, and is loaded automatically when needed.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var TEX = MathJax.InputJax.TeX;
-  var TEXDEF = TEX.Definitions;
-  
-  MathJax.Hub.Insert(TEXDEF,{
-    macros: {
-      newcommand:     'NewCommand',
-      newenvironment: 'NewEnvironment',
-      def:            'MacroDef'
-    }
-  })
-
-  TEX.Parse.Augment({
-
-    /*
-     *  Implement \newcommand{\name}[n]{...}
-     */
-    NewCommand: function (name) {
-      var cs = this.trimSpaces(this.GetArgument(name)),
-          n  = this.trimSpaces(this.GetBrackets(name)),
-          def = this.GetArgument(name);
-      if (n === '') {n = null}
-      if (cs.charAt(0) === "\\") {cs = cs.substr(1)}
-      if (!cs.match(/^(.|[a-z]+)$/i)) {TEX.Error("Illegal control sequence name for "+name)}
-      if (n != null && !n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+name)}
-      TEXDEF.macros[cs] = ['Macro',def,n];
-    },
-    
-    /*
-     *  Implement \newenvironment{name}[n]{begincmd}{endcmd}
-     */
-    NewEnvironment: function (name) {
-      var env  = this.trimSpaces(this.GetArgument(name)),
-          n    = this.trimSpaces(this.GetBrackets(name)),
-          bdef = this.GetArgument(name),
-          edef = this.GetArgument(name);
-      if (n === '') {n = null}
-      if (n != null && !n.match(/^[0-9]+$/)) {TEX.Error("Illegal number of parameters specified in "+name)}
-      TEXDEF.environment[env] = ['BeginEnv','EndEnv',bdef,edef,n];
-    },
-    
-    /*
-     *  Implement \def command
-     */
-    MacroDef: function (name) {
-      var cs     = this.GetCSname(name),
-          params = this.GetTemplate(name,"\\"+cs),
-          def    = this.GetArgument(name);
-      if (!(params instanceof Array)) {TEXDEF.macros[cs] = ['Macro',def,params]}
-        else {TEXDEF.macros[cs] = ['MacroWithTemplate',def,params[0],params[1]]}
-    },
-    
-    /*
-     *  Get a CS name or give an error
-     */
-    GetCSname: function (cmd) {
-      var c = this.GetNext();
-      if (c !== "\\") {TEX.Error("\\ must be followed by a control sequence")}
-      var cs = this.trimSpaces(this.GetArgument(cmd));
-      return cs.substr(1);
-    },
-    
-    /*
-     *  Get a \def parameter template
-     */
-    GetTemplate: function (cmd,cs) {
-      var c, params = [], n = 0;
-      c = this.GetNext(); var i = this.i;
-      while (this.i < this.string.length) {
-        c = this.GetNext();
-        if (c === '#') {
-          if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
-          c = this.string.charAt(++this.i);
-          if (!c.match(/^[1-9]$/)) {TEX.Error("Illegal use of # in template for "+cs)}
-          if (parseInt(c) != ++n) {TEX.Error("Parameters for "+cs+" must be numbered sequentially")}
-          i = this.i+1;
-        } else if (c === '{') {
-          if (i !== this.i) {params[n] = this.string.substr(i,this.i-i)}
-          if (params.length > 0) {return [n,params]} else {return n}
-        }
-        this.i++;
-      }
-      TEX.Error("Missing replacement string for definition of "+cmd);
-    },
-    
-    /*
-     *  Process a macro with a parameter template
-     */
-    MacroWithTemplate: function (name,text,n,params) {
-      if (n) {
-        var args = [], c = this.GetNext();
-        if (params[0] && !this.MatchParam(params[0]))
-          {TEX.Error("Use of "+name+" doesn't match its definition")}
-        for (var i = 0; i < n; i++) {args.push(this.GetParameter(name,params[i+1]))}
-        text = this.SubstituteArgs(args,text);
-      }
-      this.string = this.AddArgs(text,this.string.slice(this.i));
-      this.i = 0;
-    },
-    
-    /*
-     *  Process a user-defined environment
-     */
-    BeginEnv: function (begin,bdef,edef,n) {
-      if (n) {
-        var args = [];
-        for (var i = 0; i < n; i++) {args.push(this.GetArgument("\\begin{"+name+"}"))}
-        bdef = this.SubstituteArgs(args,bdef);
-        edef = this.SubstituteArgs(args,edef);
-      }
-      begin.edef = edef;
-      this.string = this.AddArgs(bdef,this.string.slice(this.i)); this.i = 0;
-      return begin;
-    },
-    EndEnv: function (begin,row) {
-      this.string = this.AddArgs(begin.edef,this.string.slice(this.i)); this.i = 0
-      return row;
-    },
-    
-    /*
-     *  Find a single parameter delimited by a trailing template
-     */
-    GetParameter: function (name,param) {
-      if (param == null) {return this.GetArgument(name)}
-      var i = this.i, j = 0, hasBraces = 0;
-      while (this.i < this.string.length) {
-        if (this.string.charAt(this.i) === '{') {
-          if (this.i === i) {hasBraces = 1}
-          this.GetArgument(name); j = this.i - i;
-        } else if (this.MatchParam(param)) {
-          if (hasBraces) {i++; j -= 2}
-          return this.string.substr(i,j);
-        } else {
-          this.i++; j++; hasBraces = 0;
-        }
-      }
-      TEX.Error("Runaway argument for "+name+"?");
-    },
-    
-    /*
-     *  Check if a template is at the current location.
-     *  (The match must be exact, with no spacing differences.  TeX is
-     *   a little more forgiving than this about spaces after macro names)
-     */
-    MatchParam: function (param) {
-      if (this.string.substr(this.i,param.length) !== param) {return 0}
-      this.i += param.length;
-      return 1;
-    }
-    
-  });
-  
-  TEX.Environment = function (name) {
-    TEXDEF.environment[name] = ['BeginEnv','EndEnv'].concat([].slice.call(arguments,1));
-  }
-
-  MathJax.Hub.Startup.signal.Post("TeX newcommand Ready");
-
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/newcommand.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/noErrors.js

@@ -1,169 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/noErrors.js
- *  
- *  Prevents the TeX error messages from being displayed and shows the
- *  original TeX code instead.  You can configure whether the dollar signs
- *  are shown or not for in-line math, and whether to put all the TeX on
- *  one line or use multiple-lines.
- *  
- *  To configure this extension, use
- *  
- *      MathJax.Hub.Configure({
- *        TeX: {
- *          noErrors: {
- *            inlineDelimiters: ["",""],   // or ["$","$"] or ["\\(","\\)"]
- *            multiLine: true,             // false for TeX on all one line
- *            style: {
- *              "font-family": "serif",
- *              "font-size":   "80%",
- *              "color":       "black",
- *              "border":      "1px solid" 
- *                // add any additional CSS styles that you want
- *                //  (be sure there is no extra comma at the end of the last item)
- *            }
- *          }
- *        }
- *      });
- *  
- *  Display-style math is always shown in multi-line format, and without
- *  delimiters, as it will already be set off in its own centered
- *  paragraph, like standard display mathematics.
- *  
- *  The default settings place the invalid TeX in a multi-line box with a
- *  black border.  If you want it to look as though the TeX is just part of
- *  the paragraph, use
- *
- *      MathJax.Hub.Configure({
- *        TeX: {
- *          noErrors: {
- *            inlineDelimiters: ["$","$"],   // or ["",""] or ["\\(","\\)"]
- *            multiLine: false,
- *            style: {
- *              "font-size": "normal",
- *              "border": ""
- *            }
- *          }
- *        }
- *      });
- *  
- *  You may also wish to set the font family, as the default is "serif"
- *  
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-(function () {
-  
-  //
-  //  The configuration defaults, augmented by the user settings
-  //  
-  MathJax.Extension["TeX/noErrors"] = {
-    config: MathJax.Hub.Insert({
-      multiLine: true,
-      inlineDelimiters: ["",""],     // or use ["$","$"] or ["\\(","\\)"]
-      style: {
-        "font-family": "serif",
-        "font-size":   "80%",
-        "color":       "black",
-        "border":      "1px solid"
-      }
-    },((MathJax.Hub.config.TeX||{}).noErrors||{}))
-  };
-  
-  var CONFIG = MathJax.Extension["TeX/noErrors"].config;
-  var NBSP = String.fromCharCode(0xA0);
-  
-  MathJax.Hub.Config({
-    TeX: {
-      Augment: {
-        //
-        //  Make error messages be the original TeX code
-        //  Mark them as errors and multi-line or not, and for
-        //  multi-line TeX, make spaces non-breakable (to get formatting right)
-        //
-        formatError: function (err,math,displaystyle,script) {
-          var delim = CONFIG.inlineDelimiters;
-          var multiLine = (displaystyle || CONFIG.multiLine);
-          if (!displaystyle) {math = delim[0] + math + delim[1]}
-          if (multiLine) {math = math.replace(/ /g,NBSP)} else {math = math.replace(/\n/g," ")}
-          return MathJax.ElementJax.mml.merror(math).With({isError:true, multiLine: multiLine});
-        }
-      }
-    },
-    
-    "HTML-CSS": {
-      styles: {
-        ".MathJax .merror": MathJax.Hub.Insert({
-          "font-style":       null,
-          "background-color": null,
-          "vertical-align":   (MathJax.Hub.Browser.isMSIE && CONFIG.multiLine ? "-2px" : "")
-        },CONFIG.style)
-      }
-    }
-  });
-
-})();
-  
-MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
-  var CONFIG = MathJax.Extension["TeX/noErrors"].config;
-  
-  //
-  // Override math toHTML routine so that error messages
-  //   don't have the clipping and other unneeded overhead
-  //
-  var math_toHTML = MML.math.prototype.toHTML;
-  MML.math.Augment({
-    toHTML: function (span) {
-      if (this.data[0] && this.data[0].data[0] && this.data[0].data[0].isError) {
-        return this.data[0].data[0].toHTML(span);
-      }
-      return math_toHTML.call(this,span);
-    }
-  });
-  
-  //
-  //  Override merror toHTML routine so that it puts out the
-  //    TeX code in an inlin-block with line breaks as in the original
-  //
-  MML.merror.Augment({
-    toHTML: function (span) {
-      span = this.HTMLcreateSpan(span);
-      if (this.multiLine) {span.style.display = "inline-block"}
-      var text = this.data[0].data.join("").split(/\n/);
-      for (var i = 0, m = text.length; i < m; i++) {
-        HTMLCSS.addText(span,text[i]);
-        if (i !== m-1) {HTMLCSS.addElement(span,"br")}
-      }
-      var HD = HTMLCSS.getHD(span.parentNode), W = HTMLCSS.getW(span.parentNode);
-      if (m > 1) {
-        var H = (HD.h + HD.d)/2, x = HTMLCSS.TeX.x_height/2;
-        var scale = HTMLCSS.config.styles[".MathJax .merror"]["font-size"];
-        if (scale && scale.match(/%/)) {x *= parseInt(scale)/100}
-        span.parentNode.style.verticalAlign = HTMLCSS.Em(HD.d+(x-H));
-        HD.h = x + H; HD.d = H - x;
-      }
-      span.bbox = {h: HD.h, d: HD.d, w: W, lw: 0, rw: W};
-      return span;
-    }
-  });
-
-  MathJax.Hub.Startup.signal.Post("TeX noErrors Ready");
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/noErrors.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/unicode.js

@@ -1,131 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/unicode.js
- *  
- *  Implements the \unicode extension to TeX to allow arbitrary unicode
- *  code points to be entered into the TeX file.  You can specify
- *  the height and depth of the character (the width is determined by
- *  the browser), and the default font from which to take the character.
- *  
- *  Examples:
- *      \unicode{65}                        % the character 'A'
- *      \unicode{x41}                       % the character 'A'
- *      \unicode[.55,0.05]{x22D6}           % less-than with dot, with height .55 and depth 0.05
- *      \unicode[.55,0.05][Geramond]{x22D6} % same taken from Geramond font
- *      \unicode[Garamond]{x22D6}           % same, but with default height, depth of .8,.2
- *
- *  Once a size and font are provided for a given conde point, they need
- *  not be specified again in subsequent \unicode calls for that character.
- *  Note that a font list can be given, but Internet Explorer has a buggy
- *  implementation of font-family where it only looks in the first
- *  available font and if the glyph is not in that, it does not look at
- *  later fonts, but goes directly to the default font as set in the
- *  Internet-Options/Font panel.  For this reason, the default font list is
- *  "STIXGeneral,'Arial Unicode MS'", so if the user has STIX fonts, the
- *  symbol will be taken from that (almost all the symbols are in
- *  STIXGeneral), otherwise Arial Unicode MS is tried.
- *  
- *  To configure the default font list, use
- *  
- *      MathJax.Hub.Configure({
- *        TeX: {
- *          unicode: {
- *            fonts: "STIXGeneral,'Arial Unicode MS'"
- *          }
- *        }
- *      });
- *
- *  The result of \unicode will have TeX class ORD (e.g., it will act like a
- *  variable).  Use \mathbin, \mathrel, etc, to specify a different class.
- *  
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-//
-//  The configuration defaults, augmented by the user settings
-//  
-MathJax.Extension["TeX/unicode"] = {
-  unicode: {},
-  config: MathJax.Hub.Insert({
-    fonts: "STIXGeneral,'Arial Unicode MS'"
-  },((MathJax.Hub.config.TeX||{}).unicode||{}))
-};
-  
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var TEX = MathJax.InputJax.TeX;
-  var MML = MathJax.ElementJax.mml;
-  var FONTS = MathJax.Extension["TeX/unicode"].config.fonts;
-  var UNICODE = MathJax.Extension["TeX/unicode"].unicode;
-  
-  //
-  //  Add \unicode macro
-  //
-  TEX.Definitions.macros.unicode = 'Unicode';
-  //
-  //  Implementation of \unicode in parser
-  //
-  TEX.Parse.Augment({
-    Unicode: function(name) {
-      var HD = this.GetBrackets(name), font;
-      if (HD) {
-        HD = HD.replace(/ /g,"");
-        if (HD.match(/^(\d+(\.\d*)?|\.\d+),(\d+(\.\d*)?|\.\d+)$/))
-          {HD = HD.split(/,/); font = this.GetBrackets(name)} else {font = HD; HD = null}
-      }
-      var n = this.trimSpaces(this.GetArgument(name)),
-          N = parseInt(n.match(/^x/) ? "0"+n : n);
-      UNICODE[N] = [800,200,500,0,500,{isUnknown:true, isUnicode:true, font:FONTS}];
-      if (HD) {
-        UNICODE[N][0] = Math.floor(HD[0]*1000);
-        UNICODE[N][1] = Math.floor(HD[1]*1000);
-      }
-      var variant = this.stack.env.font, def = {};
-      if (font) {
-        def.fontfamily = font;
-        if (variant) {
-          if (variant.match(/bold/))   {def.fontweight = "bold"}
-          if (variant.match(/italic/)) {def.fontstyle = "italic"}
-        }
-        UNICODE[N][5].font = font+","+FONTS
-      } else if (variant) {def.mathvariant = variant}
-      this.Push(MML.mtext(MML.entity("#"+n)).With(def));
-    }
-  });
-
-});
-    
-MathJax.Hub.Register.StartupHook("HTML-CSS Jax Ready",function () {
-  var HTMLCSS = MathJax.OutputJax["HTML-CSS"];
-  var UNICODE = MathJax.Extension["TeX/unicode"].unicode;
-
-  //
-  // Override lookupChar to add unicode character to font
-  //
-  var save_lookupChar = HTMLCSS.lookupChar;
-  HTMLCSS.Augment({
-    lookupChar: function (variant,n) {
-      var font = save_lookupChar.call(this,variant,n);
-      if (font[n][5] && font[n][5].isUnknown && UNICODE[n]) {font[n] = UNICODE[n]}
-      return font;
-    }
-  });
-
-  MathJax.Hub.Startup.signal.Post("TeX unicode Ready");
-  
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/unicode.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/TeX/verb.js

@@ -1,53 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/TeX/verb.js
- *  
- *  Implements the \verb|...| command for including text verbatim
- *  (with no processing of macros or special characters).
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.StartupHook("TeX Jax Ready",function () {
-  var MML = MathJax.ElementJax.mml;
-  var TEX = MathJax.InputJax.TeX;
-  var TEXDEF = TEX.Definitions;
-  
-  TEXDEF.macros.verb = 'Verb';
-
-  TEX.Parse.Augment({
-
-    /*
-     *  Implement \verb|...|
-     */
-    Verb: function (name) {
-      var c = this.GetNext(); var start = ++this.i;
-      if (c == "" ) {TEX.Error(name+" requires an argument")}
-      while (this.i < this.string.length && this.string.charAt(this.i) != c) {this.i++}
-      if (this.i == this.string.length) 
-        {TEX.Error("Can't find closing delimiter for "+name)}
-      var text = this.string.slice(start,this.i); this.i++;
-      this.Push(MML.mtext(text).With({mathvariant:MML.VARIANT.MONOSPACE}));
-    }
-    
-  });
-  
-  MathJax.Hub.Startup.signal.Post("TeX verb Ready");
-
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/TeX/verb.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/jsMath2jax.js

@@ -1,77 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/jsMath2jax.js
- *  
- *  Implements a jsMath to Jax preprocessor that locates jsMath-style
- *  <SPAN CLASS="math">...</SPAN> and <DIV CLASS="math">...</DIV> tags
- *  and replaces them with SCRIPT tags for processing by MathJax.
- *  (Note: use the tex2jax preprocessor to convert TeX delimiters or 
- *  custom delimiters to MathJax SCRIPT tags.  This preprocessor is
- *  only for the SPAN and DIV form of jsMath delimiters).
- *  
- *  To use this preprocessor, include "jsMath2jax.js" in the extensions
- *  array in your config/MathJax.js file, or the MathJax.Hub.Config() call
- *  in your HTML document.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Extension.jsMath2jax = {
-  config: {
-    previewTeX: true,   // Set to false to prevent preview strings from being inserted
-  },
-  
-  PreProcess: function (element) {
-    if (!this.configured) {
-      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.jsMath2jax||{}));
-      this.previewClass = MathJax.Hub.config.preRemoveClass;
-      this.configured = true;
-    }
-    if (typeof(element) === "string") {element = document.getElementById(element)}
-    if (!element) {element = this.config.element || document.body}
-    var span = element.getElementsByTagName("span"), i, m;
-    for (i = 0, m = span.length; i < m; i++)
-      {if (String(span[i].className).match(/\bmath\b/)) {this.ConvertMath(span[i],"")}}
-    var div = element.getElementsByTagName("div");
-    for (i = 0, m = div.length; i < m; i++)
-      {if (String(div[i].className).match(/\bmath\b/)) {this.ConvertMath(div[i],"; mode=display")}}
-  },
-  
-  ConvertMath: function (node,mode) {
-    var parent = node.parentNode,
-        script = this.CreateMathTag(mode,node.innerHTML);
-    if (node.nextSibling) {parent.insertBefore(script,node.nextSibling)}
-      else {parent.appendChild(script)}
-    if (this.config.previewTeX) {
-      node.className = String(node.className).replace(/\bmath\b/,this.previewClass);
-    } else {
-      parent.removeChild(node);
-    }
-  },
-  
-  CreateMathTag: function (mode,tex) {
-    var script = document.createElement("script");
-    script.type = "math/tex" + mode;
-    if (MathJax.Hub.Browser.isMSIE) {script.text = tex}
-      else {script.appendChild(document.createTextNode(tex))}
-    return script;
-  }
-  
-};
-
-MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.jsMath2jax]);
-MathJax.Ajax.loadComplete("[MathJax]/extensions/jsMath2jax.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/mml2jax.js

@@ -1,101 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/mml2jax.js
- *  
- *  Implements the MathML to Jax preprocessor that locates <math> nodes
- *  within the text of a document and replaces them with SCRIPT tags
- *  for processing by MathJax.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Extension.mml2jax = {
-  config: {
-    element: null           // The ID of the element to be processed
-                            //   (defaults to full document)
-  },
-  MMLnamespace: "http://www.w3.org/1998/Math/MathML",
-  
-  PreProcess: function (element) {
-    if (!this.configured) {
-      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.mml2jax||{}));
-      this.configured = true;
-    }
-    if (typeof(element) === "string") {element = document.getElementById(element)}
-    if (!element) {element = this.config.element || document.body}
-    var math = element.getElementsByTagName("math");
-    if (math.length === 0 && element.getElementsByTagNameNS)
-      {math = element.getElementsByTagNameNS(this.MMLnamespace,"math")}
-    if (this.msieMathTagBug) {
-      for (var i = math.length-1; i >= 0; i--) {
-        if (math[i].nodeName === "MATH") {this.msieProcessMath(math[i])}
-                                    else {this.ProcessMath(math[i])}
-      }
-    } else {
-      for (var i = math.length-1; i >= 0; i--) {this.ProcessMath(math[i])}
-    }
-  },
-  
-  ProcessMath: function (math) {
-    var parent = math.parentNode;
-    var script = document.createElement("script");
-    script.type = "math/mml";
-    parent.insertBefore(script,math);
-    if (this.msieScriptBug) {
-      var html = math.outerHTML; var prefix;
-      html = html.replace(/<\?import .*?>/,"").replace(/<(\/?)m:/g,"<$1").replace(/&nbsp;/g,"&#xA0;");
-      script.text = html;
-      parent.removeChild(math);
-    } else {
-      script.appendChild(math);
-    }
-  },
-  
-  msieProcessMath: function (math) {
-    var parent = math.parentNode;
-    var script = document.createElement("script");
-    script.type = "math/mml";
-    parent.insertBefore(script,math);
-    var mml = "";
-    while (math && math.nodeName !== "/MATH") {
-      if (math.nodeName === "#text" || math.nodeName === "#comment")
-        {mml += math.nodeValue} else {mml += this.toLowerCase(math.outerHTML)}
-      var node = math;
-      math = math.nextSibling;
-      node.parentNode.removeChild(node);
-    }
-    script.text = mml + "</math>";
-  },
-  toLowerCase: function (string) {
-    var parts = string.split(/"/);
-    for (var i = 0, m = parts.length; i < m; i += 2) {parts[i] = parts[i].toLowerCase()}
-    return parts.join('"');
-  }
-  
-};
-
-MathJax.Hub.Browser.Select({
-  MSIE: function (browser) {
-    MathJax.Hub.Insert(MathJax.Extension.mml2jax,{
-      msieScriptBug: true,
-      msieMathTagBug: true
-    })
-  }
-});
-  
-MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.mml2jax]);
-MathJax.Ajax.loadComplete("[MathJax]/extensions/mml2jax.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/tex2jax.js

@@ -1,242 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/tex2jax.js
- *  
- *  Implements the TeX to Jax preprocessor that locates TeX code
- *  within the text of a document and replaces it with SCRIPT tags
- *  for processing by MathJax.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Extension.tex2jax = {
-  config: {
-    element: null,          // The ID of the element to be processed
-                            //   (defaults to full document)
-
-    inlineMath: [           // The start/stop pairs for in-line math
-      ['$','$'],            //  (comment out any you don't want, or add your own, but
-      ['\\(','\\)']         //  be sure that you don't have an extra comma at the end)
-    ],
-
-    displayMath: [          // The start/stop pairs for display math
-      ['$$','$$'],          //  (comment out any you don't want, or add your own, but
-      ['\\[','\\]']         //  be sure that you don't have an extra comma at the end)
-    ],
-
-    processEscapes: 0,      // set to 1 to allow \$ to produce a dollar without
-                            //   starting in-line math mode
-
-    processEnvironments: 1, // set to 1 to process \begin{xxx}...\end{xxx} outside
-                            //   of math mode
-
-    previewTeX: 1           // set to 0 to not insert MathJax_Preview spans
-
-  },
-  
-  PreProcess: function (element) {
-    if (!this.configured) {
-      MathJax.Hub.Insert(this.config,(MathJax.Hub.config.tex2jax||{}));
-      this.configured = true;
-    }
-    if (typeof(element) === "string") {element = document.getElementById(element)}
-    if (!element) {element = this.config.element || document.body}
-    this.createPatterns();
-    this.scanElement(element,element.nextSibling);
-  },
-  
-  createPatterns: function () {
-    var starts = [], i, m, config = this.config;
-    this.match = {};
-    for (i = 0, m = config.inlineMath.length; i < m; i++) {
-      starts.push(this.patternQuote(config.inlineMath[i][0]));
-      this.match[config.inlineMath[i][0]] = {
-        mode: "",
-        end: config.inlineMath[i][1],
-        pattern: this.endPattern(config.inlineMath[i][1])
-      };
-    }
-    for (i = 0, m = config.displayMath.length; i < m; i++) {
-      starts.push(this.patternQuote(config.displayMath[i][0]));
-      this.match[config.displayMath[i][0]] = {
-        mode: "; mode=display",
-        end: config.displayMath[i][1],
-        pattern: this.endPattern(config.displayMath[i][1])
-      };
-    }
-    this.start = new RegExp(
-        starts.sort(this.sortLength).join("|") + 
-        (config.processEnvironments ? "|\\\\begin\\{([^}]*)\\}" : "") + 
-        (config.processEscapes ? "|\\\\*\\\\\\\$" : ""), "g"
-    );
-  },
-  
-  patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')},
-  
-  endPattern: function (end) {
-    return new RegExp(this.patternQuote(end)+"|\\\\.","g");
-  },
-  
-  sortLength: function (a,b) {
-    if (a.length !== b.length) {return b.length - a.length}
-    return (a == b ? 0 : (a < b ? -1 : 1));
-  },
-  
-  scanElement: function (element,stop,ignore) {
-    var cname, tname;
-    while (element && element != stop) {
-      if (element.nodeName.toLowerCase() === '#text') {
-        if (!ignore) {element = this.scanText(element)}
-      } else {
-        cname = (typeof(element.className) === "undefined" ? "" : element.className);
-        tname = (typeof(element.tagName)   === "undefined" ? "" : element.tagName);
-        if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names!
-        if (element.firstChild && !cname.match(/(^| )MathJax/) &&
-             !tname.match(/^(script|noscript|style|textarea|pre|code)$/i)) {
-          ignore = (ignore || cname.match(/(^| )tex2jax_ignore( |$)/)) &&
-                    !cname.match(/(^| )tex2jax_process( |$)/);
-          this.scanElement(element.firstChild,stop,ignore);
-        }
-      }
-      if (element) {element = element.nextSibling}
-    }
-  },
-  
-  scanText: function (element) {
-    if (element.nodeValue.replace(/\s+/,'') == '') {return element}
-    var match, prev;
-    this.search = {start: true};
-    this.pattern = this.start;
-    while (element) {
-      this.pattern.lastIndex = 0;
-      while (element && element.nodeName.toLowerCase() === '#text' &&
-            (match = this.pattern.exec(element.nodeValue))) {
-        if (this.search.start) {element = this.startMatch(match,element)}
-                          else {element = this.endMatch(match,element)}
-      }
-      if (this.search.matched) {element = this.encloseMath(element)}
-      if (element) {
-        do {prev = element; element = element.nextSibling} 
-          while (element && (element.nodeName.toLowerCase() === 'br' ||
-                             element.nodeName.toLowerCase() === '#comment'));
-        if (!element || element.nodeName !== '#text') {return prev}
-      }
-    }
-    return element;
-  },
-  
-  startMatch: function (match,element) {
-    var delim = this.match[match[0]];
-    if (delim != null) {                              // a start delimiter
-      this.search = {
-        end: delim.end, mode: delim.mode,
-        open: element, olen: match[0].length, opos: this.pattern.lastIndex - match[0].length
-      };
-      this.switchPattern(delim.pattern);
-    } else if (match[0].substr(0,6) === "\\begin") {  // \begin{...}
-      this.search = {
-        end: "\\end{"+match[1]+"}", mode: "; mode=display",
-        open: element, olen: 0, opos: this.pattern.lastIndex - match[0].length,
-        isBeginEnd: true
-      };
-      this.switchPattern(this.endPattern(this.search.end));
-    } else {                                         // escaped dollar signs
-      var dollar = match[0].replace(/\\(.)/g,'$1');
-      element.nodeValue = element.nodeValue.substr(0,match.index) + dollar +
-                          element.nodeValue.substr(match.index + match[0].length);
-      this.pattern.lastIndex -= match[0].length - dollar.length;
-    }
-    return element;
-  },
-  
-  endMatch: function (match,element) {
-    if (match[0] == this.search.end) {
-      this.search.close = element;
-      this.search.cpos = this.pattern.lastIndex;
-      this.search.clen = (this.search.isBeginEnd ? 0 : match[0].length);
-      this.search.matched = true;
-      element = this.encloseMath(element);
-      this.switchPattern(this.start);
-    }
-    return element;
-  },
-  
-  switchPattern: function (pattern) {
-    pattern.lastIndex = this.pattern.lastIndex;
-    this.pattern = pattern;
-    this.search.start = (pattern === this.start);
-  },
-  
-  encloseMath: function (element) {
-    var search = this.search, close = search.close, CLOSE;
-    if (search.cpos === close.length) {close = close.nextSibling}
-       else {close = close.splitText(search.cpos)}
-    if (!close) {CLOSE = close = search.close.parentNode.appendChild(document.createTextNode(""))}
-    if (element === search.close) {element = close}
-    search.close = close;
-    var math = search.open.splitText(search.opos);
-    while (math.nextSibling && math.nextSibling !== close) {
-      if (math.nextSibling.nodeValue !== null) {
-        if (math.nextSibling.nodeName === "#comment") {
-          math.nodeValue += math.nextSibling.nodeValue.replace(/^\[CDATA\[(.*)\]\]$/,"$1");
-        } else {
-          math.nodeValue += math.nextSibling.nodeValue;
-        }
-      } else {math.nodeValue += ' '}
-      math.parentNode.removeChild(math.nextSibling);
-    }
-    var TeX = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen);
-    math.parentNode.removeChild(math);
-    if (this.config.previewTeX) {this.createMathPreview(search.mode,TeX)}
-    math = this.createMathTag(search.mode,TeX);
-    this.search = {}; this.pattern.lastIndex = 0;
-    if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)}
-    return math;
-  },
-  
-  insertNode: function (node) {
-    var search = this.search;
-    if (search.close && search.close.parentNode) {
-      search.close.parentNode.insertBefore(node,search.close);
-    } else if (search.open.nextSibling) {
-      search.open.parentNode.insertBefore(node,search.open.nextSibling);
-    } else {
-      search.open.parentNode.appendChild(node);
-    }
-  },
-  
-  createMathPreview: function (mode,tex) {
-    var preview = document.createElement("span");
-    preview.className = MathJax.Hub.config.preRemoveClass;
-    preview.appendChild(document.createTextNode(tex));
-    this.insertNode(preview);
-    return preview;
-  },
-  
-  createMathTag: function (mode,tex) {
-    var script = document.createElement("script");
-    script.type = "math/tex" + mode;
-    if (MathJax.Hub.Browser.isMSIE) {script.text = tex}
-      else {script.appendChild(document.createTextNode(tex))}
-    this.insertNode(script);
-    return script;
-  }
-  
-};
-
-MathJax.Hub.Register.PreProcessor(["PreProcess",MathJax.Extension.tex2jax]);
-MathJax.Ajax.loadComplete("[MathJax]/extensions/tex2jax.js");

lib/gollum/frontend/public/javascript/MathJax/extensions/toMathML.js

@@ -1,140 +0,0 @@
-/*************************************************************
- *
- *  MathJax/extensions/toMathML.js
- *  
- *  Implements a toMathML() method for the mml Element Jax that returns
- *  a MathML string from a given math expression.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.Hub.Register.LoadHook("[MathJax]/jax/element/mml/jax.js",function () {
-  var MML = MathJax.ElementJax.mml;
-  
-  MML.mbase.Augment({
-
-    toMathML: function (space) {
-      var inferred = (this.inferred && this.parent.inferRow);
-      if (space == null) {space = ""}
-      var tag = this.type, attr = this.MathMLattributes();
-      if (tag === "mspace") {return space + "<"+tag+attr+" />"}
-      var data = []; var SPACE = (this.isToken ? "" : space+(inferred ? "" : "  "));
-      for (var i = 0, m = this.data.length; i < m; i++) {
-        if (this.data[i]) {data.push(this.data[i].toMathML(SPACE))}
-          else if (!this.isToken) {data.push(SPACE+"<mrow />")}
-      }
-      if (this.isToken) {return space + "<"+tag+attr+">"+data.join("")+"</"+tag+">"}
-      if (inferred) {return data.join("\n")}
-      if (data.length === 0 || (data.length === 1 && data[0] === ""))
-        {return space + "<"+tag+attr+" />"}
-      return space + "<"+tag+attr+">\n"+data.join("\n")+"\n"+ space +"</"+tag+">";
-    },
-
-    MathMLattributes: function () {
-      var attr = [], defaults = this.defaults;
-      var copy = this.copyAttributes,
-          skip = this.skipAttributes;
-
-      if (this.type === "mstyle") {defaults = MML.math.prototype.defaults}
-      for (var id in defaults) {if (!skip[id] && defaults.hasOwnProperty(id)) {
-        var force = (id === "open" || id === "close");
-        if (this[id] != null && (force || this[id] !== defaults[id])) {
-          var value = this[id]; delete this[id];
-          if (force || this.Get(id) !== value)
-            {attr.push(id+'="'+this.quoteHTML(value)+'"')}
-          this[id] = value;
-        }
-      }}
-      for (var i = 0, m = copy.length; i < m; i++) {
-        if (this[copy[i]] != null) {attr.push(copy[i]+'="'+this.quoteHTML(this[copy[i]])+'"')}
-      }
-      if (attr.length) {return " "+attr.join(" ")} else {return ""}
-    },
-    copyAttributes: [
-      "fontfamily","fontsize","fontweight","fontstyle",
-      "color","background",
-      "id","class","href","style"
-    ],
-    skipAttributes: {texClass: 1, useHeight: 1, texprimestyle: 1},
-    
-    quoteHTML: function (string) {
-      string = String(string).split("");
-      for (var i = 0, m = string.length; i < m; i++) {
-        var n = string[i].charCodeAt(0);
-        if (n < 0x20 || n > 0x7E) {
-          string[i] = "&#x"+n.toString(16).toUpperCase()+";";
-        } else {
-          var c = {'&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;'}[string[i]];
-          if (c) {string[i] = c}
-        }
-      }
-      return string.join("");
-    }
-  });
-  
-  MML.msubsup.Augment({
-    toMathML: function (space) {
-      var tag = this.type;
-      if (this.data[this.sup] == null) {tag = "msub"}
-      if (this.data[this.sub] == null) {tag = "msup"}
-      var attr = this.MathMLattributes();
-      delete this.data[0].inferred;
-      var data = [];
-      for (var i = 0, m = this.data.length; i < m; i++)
-        {if (this.data[i]) {data.push(this.data[i].toMathML(space+"  "))}}
-      return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
-    }
-  });
-  
-  MML.munderover.Augment({
-    toMathML: function (space) {
-      var tag = this.type;
-      if (this.data[this.under] == null) {tag = "mover"}
-      if (this.data[this.over] == null)  {tag = "munder"}
-      var attr = this.MathMLattributes();
-      delete this.data[0].inferred;
-      var data = [];
-      for (var i = 0, m = this.data.length; i < m; i++)
-        {if (this.data[i]) {data.push(this.data[i].toMathML(space+"  "))}}
-      return space + "<"+tag+attr+">\n" + data.join("\n") + "\n" + space + "</"+tag+">";
-    }
-  });
-  
-  MML.TeXAtom.Augment({
-    toMathML: function (space) {
-      // FIXME:  Handle spacing using mpadded?
-      return space+"<mrow>\n"+this.data[0].toMathML(space+"  ")+"\n"+space+"</mrow>";
-    }
-  });
-  
-  MML.chars.Augment({
-    toMathML: function (space) {return (space||"") + this.quoteHTML(this.toString())}
-  });
-  
-  MML.entity.Augment({
-    toMathML: function (space) {return (space||"") + "&"+this.data[0]+";<!-- "+this.toString()+" -->"}
-  });
-  
-  MathJax.Hub.Register.StartupHook("TeX mathchoice Ready",function () {
-    MML.TeXmathchoice.Augment({
-      toMathML: function (space) {return this.Core().toMathML(space)}
-    });
-  });
-  
-});
-
-MathJax.Ajax.loadComplete("[MathJax]/extensions/toMathML.js");

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/Arrows.js

@@ -1,122 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/Arrows.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      infix: {
-        '\u219A': MO.REL,      // leftwards arrow with stroke
-        '\u219B': MO.REL,      // rightwards arrow with stroke
-        '\u219C': MO.WIDEREL,  // leftwards wave arrow
-        '\u219D': MO.WIDEREL,  // rightwards wave arrow
-        '\u219E': MO.WIDEREL,  // leftwards two headed arrow
-        '\u219F': MO.WIDEREL,  // upwards two headed arrow
-        '\u21A0': MO.WIDEREL,  // rightwards two headed arrow
-        '\u21A1': MO.WIDEREL,  // downwards two headed arrow
-        '\u21A2': MO.WIDEREL,  // leftwards arrow with tail
-        '\u21A3': MO.WIDEREL,  // rightwards arrow with tail
-        '\u21A4': MO.WIDEREL,  // leftwards arrow from bar
-        '\u21A5': MO.WIDEREL,  // upwards arrow from bar
-        '\u21A7': MO.WIDEREL,  // downwards arrow from bar
-        '\u21A8': MO.WIDEREL,  // up down arrow with base
-        '\u21AB': MO.WIDEREL,  // leftwards arrow with loop
-        '\u21AC': MO.WIDEREL,  // rightwards arrow with loop
-        '\u21AD': MO.WIDEREL,  // left right wave arrow
-        '\u21AE': MO.REL,      // left right arrow with stroke
-        '\u21AF': MO.WIDEREL,  // downwards zigzag arrow
-        '\u21B0': MO.WIDEREL,  // upwards arrow with tip leftwards
-        '\u21B1': MO.WIDEREL,  // upwards arrow with tip rightwards
-        '\u21B2': MO.WIDEREL,  // downwards arrow with tip leftwards
-        '\u21B3': MO.WIDEREL,  // downwards arrow with tip rightwards
-        '\u21B4': MO.WIDEREL,  // rightwards arrow with corner downwards
-        '\u21B5': MO.WIDEREL,  // downwards arrow with corner leftwards
-        '\u21B6': MO.REL,      // anticlockwise top semicircle arrow
-        '\u21B7': MO.REL,      // clockwise top semicircle arrow
-        '\u21B8': MO.REL,      // north west arrow to long bar
-        '\u21B9': MO.WIDEREL,  // leftwards arrow to bar over rightwards arrow to bar
-        '\u21BA': MO.REL,      // anticlockwise open circle arrow
-        '\u21BB': MO.REL,      // clockwise open circle arrow
-        '\u21BE': MO.WIDEREL,  // upwards harpoon with barb rightwards
-        '\u21BF': MO.WIDEREL,  // upwards harpoon with barb leftwards
-        '\u21C2': MO.WIDEREL,  // downwards harpoon with barb rightwards
-        '\u21C3': MO.WIDEREL,  // downwards harpoon with barb leftwards
-        '\u21C4': MO.WIDEREL,  // rightwards arrow over leftwards arrow
-        '\u21C5': MO.WIDEREL,  // upwards arrow leftwards of downwards arrow
-        '\u21C6': MO.WIDEREL,  // leftwards arrow over rightwards arrow
-        '\u21C7': MO.WIDEREL,  // leftwards paired arrows
-        '\u21C8': MO.WIDEREL,  // upwards paired arrows
-        '\u21C9': MO.WIDEREL,  // rightwards paired arrows
-        '\u21CA': MO.WIDEREL,  // downwards paired arrows
-        '\u21CB': MO.WIDEREL,  // leftwards harpoon over rightwards harpoon
-        '\u21CD': MO.REL,      // leftwards double arrow with stroke
-        '\u21CE': MO.REL,      // left right double arrow with stroke
-        '\u21CF': MO.REL,      // rightwards double arrow with stroke
-        '\u21D6': MO.WIDEREL,  // north west double arrow
-        '\u21D7': MO.WIDEREL,  // north east double arrow
-        '\u21D8': MO.WIDEREL,  // south east double arrow
-        '\u21D9': MO.WIDEREL,  // south west double arrow
-        '\u21DA': MO.WIDEREL,  // leftwards triple arrow
-        '\u21DB': MO.WIDEREL,  // rightwards triple arrow
-        '\u21DC': MO.WIDEREL,  // leftwards squiggle arrow
-        '\u21DD': MO.WIDEREL,  // rightwards squiggle arrow
-        '\u21DE': MO.REL,      // upwards arrow with double stroke
-        '\u21DF': MO.REL,      // downwards arrow with double stroke
-        '\u21E0': MO.WIDEREL,  // leftwards dashed arrow
-        '\u21E1': MO.WIDEREL,  // upwards dashed arrow
-        '\u21E2': MO.WIDEREL,  // rightwards dashed arrow
-        '\u21E3': MO.WIDEREL,  // downwards dashed arrow
-        '\u21E4': MO.WIDEREL,  // leftwards arrow to bar
-        '\u21E5': MO.WIDEREL,  // rightwards arrow to bar
-        '\u21E6': MO.WIDEREL,  // leftwards white arrow
-        '\u21E7': MO.WIDEREL,  // upwards white arrow
-        '\u21E8': MO.WIDEREL,  // rightwards white arrow
-        '\u21E9': MO.WIDEREL,  // downwards white arrow
-        '\u21EA': MO.WIDEREL,  // upwards white arrow from bar
-        '\u21EB': MO.WIDEREL,  // upwards white arrow on pedestal
-        '\u21EC': MO.WIDEREL,  // upwards white arrow on pedestal with horizontal bar
-        '\u21ED': MO.WIDEREL,  // upwards white arrow on pedestal with vertical bar
-        '\u21EE': MO.WIDEREL,  // upwards white double arrow
-        '\u21EF': MO.WIDEREL,  // upwards white double arrow on pedestal
-        '\u21F0': MO.WIDEREL,  // rightwards white arrow from wall
-        '\u21F1': MO.REL,      // north west arrow to corner
-        '\u21F2': MO.REL,      // south east arrow to corner
-        '\u21F3': MO.WIDEREL,  // up down white arrow
-        '\u21F4': MO.REL,      // right arrow with small circle
-        '\u21F5': MO.WIDEREL,  // downwards arrow leftwards of upwards arrow
-        '\u21F6': MO.WIDEREL,  // three rightwards arrows
-        '\u21F7': MO.REL,      // leftwards arrow with vertical stroke
-        '\u21F8': MO.REL,      // rightwards arrow with vertical stroke
-        '\u21F9': MO.REL,      // left right arrow with vertical stroke
-        '\u21FA': MO.REL,      // leftwards arrow with double vertical stroke
-        '\u21FB': MO.REL,      // rightwards arrow with double vertical stroke
-        '\u21FC': MO.REL,      // left right arrow with double vertical stroke
-        '\u21FD': MO.WIDEREL,  // leftwards open-headed arrow
-        '\u21FE': MO.WIDEREL,  // rightwards open-headed arrow
-        '\u21FF': MO.WIDEREL   // left right open-headed arrow
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/BasicLatin.js

@@ -1,58 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
-        '\'': MO.ACCENT,       // apostrophe
-        '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
-        '--': [0,0,TEXCLASS.BIN], // multiple character operator: --
-        '..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
-        '...': MO.ORD          // multiple character operator: ...
-      },
-      infix: {
-        '!=': MO.BIN4,         // multiple character operator: !=
-        '&&': MO.BIN4,         // multiple character operator: &&
-        '**': [1,1,TEXCLASS.BIN], // multiple character operator: **
-        '*=': MO.BIN4,         // multiple character operator: *=
-        '+=': MO.BIN4,         // multiple character operator: +=
-        '-=': MO.BIN4,         // multiple character operator: -=
-        '->': MO.BIN4,         // multiple character operator: ->
-        '//': MO.BIN4,         // multiple character operator: //
-        '/=': MO.BIN4,         // multiple character operator: /=
-        ':=': MO.BIN4,         // multiple character operator: :=
-        '<=': MO.BIN4,         // multiple character operator: <=
-        '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
-        '==': MO.BIN4,         // multiple character operator: ==
-        '>=': MO.BIN4,         // multiple character operator: >=
-        '@': MO.ORD11,         // commercial at
-        '||': MO.BIN3          // multiple character operator: ||
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/CombDiacritMarks.js

@@ -1,35 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '\u0311': MO.ACCENT    // combining inverted breve
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/CombDiactForSymbols.js

@@ -1,35 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/CombDiactForSymbols.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '\u20DB': MO.ACCENT    // combining three dots above
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiactForSymbols.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/Dingbats.js

@@ -1,35 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/Dingbats.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      infix: {
-        '\u2713': MO.WIDEACCENT  // check mark
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/GeneralPunctuation.js

@@ -1,40 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark
-        '\u201C': [0,0,TEXCLASS.OPEN,{fence: true}]  // left double quotation mark
-      },
-      postfix: {
-        '\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark
-        '\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}]  // right double quotation mark
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/GeometricShapes.js

@@ -1,66 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      infix: {
-        '\u25A0': MO.BIN3,     // black square
-        '\u25A1': MO.BIN3,     // white square
-        '\u25AA': MO.BIN3,     // black small square
-        '\u25AB': MO.BIN3,     // white small square
-        '\u25AD': MO.BIN3,     // white rectangle
-        '\u25AE': MO.BIN3,     // black vertical rectangle
-        '\u25AF': MO.BIN3,     // white vertical rectangle
-        '\u25B0': MO.BIN3,     // black parallelogram
-        '\u25B1': MO.BIN3,     // white parallelogram
-        '\u25B2': MO.BIN4,     // black up-pointing triangle
-        '\u25B4': MO.BIN4,     // black up-pointing small triangle
-        '\u25B6': MO.BIN4,     // black right-pointing triangle
-        '\u25B7': MO.BIN4,     // white right-pointing triangle
-        '\u25B8': MO.BIN4,     // black right-pointing small triangle
-        '\u25BC': MO.BIN4,     // black down-pointing triangle
-        '\u25BE': MO.BIN4,     // black down-pointing small triangle
-        '\u25C0': MO.BIN4,     // black left-pointing triangle
-        '\u25C1': MO.BIN4,     // white left-pointing triangle
-        '\u25C2': MO.BIN4,     // black left-pointing small triangle
-        '\u25C4': MO.BIN4,     // black left-pointing pointer
-        '\u25C5': MO.BIN4,     // white left-pointing pointer
-        '\u25C6': MO.BIN4,     // black diamond
-        '\u25C7': MO.BIN4,     // white diamond
-        '\u25C8': MO.BIN4,     // white diamond containing black small diamond
-        '\u25C9': MO.BIN4,     // fisheye
-        '\u25CC': MO.BIN4,     // dotted circle
-        '\u25CD': MO.BIN4,     // circle with vertical fill
-        '\u25CE': MO.BIN4,     // bullseye
-        '\u25CF': MO.BIN4,     // black circle
-        '\u25D6': MO.BIN4,     // left half black circle
-        '\u25D7': MO.BIN4,     // right half black circle
-        '\u25E6': MO.BIN4      // white bullet
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/GreekAndCoptic.js

@@ -1,35 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u03C3': MO.ORD11     // greek small letter sigma
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/Latin1Supplement.js

@@ -1,37 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/Latin1Supplement.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '\u00B0': MO.ORD,      // degree sign
-        '\u00B4': MO.ACCENT,   // acute accent
-        '\u00B8': MO.ACCENT    // cedilla
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/Latin1Supplement.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/LetterlikeSymbols.js

@@ -1,39 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u2145': MO.ORD21,    // double-struck italic capital d
-        '\u2146': [2,0,TEXCLASS.ORD], // double-struck italic small d
-        '\u2147': MO.ORD,      // double-struck italic small e
-        '\u2148': MO.ORD,      // double-struck italic small i
-        '\u2149': MO.ORD       // double-struck italic small j
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/MathOperators.js

@@ -1,228 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/MathOperators.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u2204': MO.ORD21,    // there does not exist
-        '\u221B': MO.ORD11,    // cube root
-        '\u221C': MO.ORD11,    // fourth root
-        '\u2221': MO.ORD,      // measured angle
-        '\u2222': MO.ORD,      // spherical angle
-        '\u222C': MO.INTEGRAL, // double integral
-        '\u222D': MO.INTEGRAL, // triple integral
-        '\u222F': MO.INTEGRAL, // surface integral
-        '\u2230': MO.INTEGRAL, // volume integral
-        '\u2231': MO.INTEGRAL, // clockwise integral
-        '\u2232': MO.INTEGRAL, // clockwise contour integral
-        '\u2233': MO.INTEGRAL  // anticlockwise contour integral
-      },
-      infix: {
-        '\u2201': [1,2,TEXCLASS.ORD], // complement
-        '\u2206': MO.BIN3,     // increment
-        '\u220A': MO.REL,      // small element of
-        '\u220C': MO.REL,      // does not contain as member
-        '\u220D': MO.REL,      // small contains as member
-        '\u220E': MO.BIN3,     // end of proof
-        '\u2214': MO.BIN4,     // dot plus
-        '\u221F': MO.REL,      // right angle
-        '\u2224': MO.REL,      // does not divide
-        '\u2226': MO.REL,      // not parallel to
-        '\u2234': MO.REL,      // therefore
-        '\u2235': MO.REL,      // because
-        '\u2236': MO.REL,      // ratio
-        '\u2237': MO.REL,      // proportion
-        '\u2238': MO.BIN4,     // dot minus
-        '\u2239': MO.REL,      // excess
-        '\u223A': MO.BIN4,     // geometric proportion
-        '\u223B': MO.REL,      // homothetic
-        '\u223D': MO.REL,      // reversed tilde
-        '\u223D\u0331': MO.BIN3, // reversed tilde with underline
-        '\u223E': MO.REL,      // inverted lazy s
-        '\u223F': MO.BIN3,     // sine wave
-        '\u2241': MO.REL,      // not tilde
-        '\u2242': MO.REL,      // minus tilde
-        '\u2242\u0338': MO.BIN4, // minus tilde with slash
-        '\u2244': MO.REL,      // not asymptotically equal to
-        '\u2246': MO.REL,      // approximately but not actually equal to
-        '\u2247': MO.REL,      // neither approximately nor actually equal to
-        '\u2249': MO.REL,      // not almost equal to
-        '\u224A': MO.REL,      // almost equal or equal to
-        '\u224B': MO.REL,      // triple tilde
-        '\u224C': MO.REL,      // all equal to
-        '\u224E': MO.REL,      // geometrically equivalent to
-        '\u224E\u0338': MO.BIN4, // geometrically equivalent to with slash
-        '\u224F': MO.REL,      // difference between
-        '\u224F\u0338': MO.BIN4, // difference between with slash
-        '\u2251': MO.REL,      // geometrically equal to
-        '\u2252': MO.REL,      // approximately equal to or the image of
-        '\u2253': MO.REL,      // image of or approximately equal to
-        '\u2254': MO.REL,      // colon equals
-        '\u2255': MO.REL,      // equals colon
-        '\u2256': MO.REL,      // ring in equal to
-        '\u2257': MO.REL,      // ring equal to
-        '\u2258': MO.REL,      // corresponds to
-        '\u2259': MO.REL,      // estimates
-        '\u225A': MO.REL,      // equiangular to
-        '\u225C': MO.REL,      // delta equal to
-        '\u225D': MO.REL,      // equal to by definition
-        '\u225E': MO.REL,      // measured by
-        '\u225F': MO.REL,      // questioned equal to
-        '\u2262': MO.REL,      // not identical to
-        '\u2263': MO.REL,      // strictly equivalent to
-        '\u2266': MO.REL,      // less-than over equal to
-        '\u2266\u0338': MO.BIN4, // less-than over equal to with slash
-        '\u2267': MO.REL,      // greater-than over equal to
-        '\u2268': MO.REL,      // less-than but not equal to
-        '\u2269': MO.REL,      // greater-than but not equal to
-        '\u226A\u0338': MO.BIN4, // much less than with slash
-        '\u226B\u0338': MO.BIN4, // much greater than with slash
-        '\u226C': MO.REL,      // between
-        '\u226D': MO.REL,      // not equivalent to
-        '\u226E': MO.REL,      // not less-than
-        '\u226F': MO.REL,      // not greater-than
-        '\u2270': MO.REL,      // neither less-than nor equal to
-        '\u2271': MO.REL,      // neither greater-than nor equal to
-        '\u2272': MO.REL,      // less-than or equivalent to
-        '\u2273': MO.REL,      // greater-than or equivalent to
-        '\u2274': MO.REL,      // neither less-than nor equivalent to
-        '\u2275': MO.REL,      // neither greater-than nor equivalent to
-        '\u2276': MO.REL,      // less-than or greater-than
-        '\u2277': MO.REL,      // greater-than or less-than
-        '\u2278': MO.REL,      // neither less-than nor greater-than
-        '\u2279': MO.REL,      // neither greater-than nor less-than
-        '\u227C': MO.REL,      // precedes or equal to
-        '\u227D': MO.REL,      // succeeds or equal to
-        '\u227E': MO.REL,      // precedes or equivalent to
-        '\u227F': MO.REL,      // succeeds or equivalent to
-        '\u227F\u0338': MO.BIN4, // succeeds or equivalent to with slash
-        '\u2280': MO.REL,      // does not precede
-        '\u2281': MO.REL,      // does not succeed
-        '\u2282\u20D2': MO.BIN4, // subset of with vertical line
-        '\u2283\u20D2': MO.BIN4, // superset of with vertical line
-        '\u2284': MO.REL,      // not a subset of
-        '\u2285': MO.REL,      // not a superset of
-        '\u2288': MO.REL,      // neither a subset of nor equal to
-        '\u2289': MO.REL,      // neither a superset of nor equal to
-        '\u228A': MO.REL,      // subset of with not equal to
-        '\u228B': MO.REL,      // superset of with not equal to
-        '\u228C': MO.BIN4,     // multiset
-        '\u228D': MO.BIN4,     // multiset multiplication
-        '\u228F': MO.REL,      // square image of
-        '\u228F\u0338': MO.BIN4, // square image of with slash
-        '\u2290': MO.REL,      // square original of
-        '\u2290\u0338': MO.BIN4, // square original of with slash
-        '\u229A': MO.BIN4,     // circled ring operator
-        '\u229B': MO.BIN4,     // circled asterisk operator
-        '\u229C': MO.BIN4,     // circled equals
-        '\u229D': MO.BIN4,     // circled dash
-        '\u229E': MO.BIN4,     // squared plus
-        '\u229F': MO.BIN4,     // squared minus
-        '\u22A0': MO.BIN4,     // squared times
-        '\u22A1': MO.BIN4,     // squared dot operator
-        '\u22A6': MO.REL,      // assertion
-        '\u22A7': MO.REL,      // models
-        '\u22A9': MO.REL,      // forces
-        '\u22AA': MO.REL,      // triple vertical bar right turnstile
-        '\u22AB': MO.REL,      // double vertical bar double right turnstile
-        '\u22AC': MO.REL,      // does not prove
-        '\u22AD': MO.REL,      // not true
-        '\u22AE': MO.REL,      // does not force
-        '\u22AF': MO.REL,      // negated double vertical bar double right turnstile
-        '\u22B0': MO.REL,      // precedes under relation
-        '\u22B1': MO.REL,      // succeeds under relation
-        '\u22B2': MO.REL,      // normal subgroup of
-        '\u22B3': MO.REL,      // contains as normal subgroup
-        '\u22B4': MO.REL,      // normal subgroup of or equal to
-        '\u22B5': MO.REL,      // contains as normal subgroup or equal to
-        '\u22B6': MO.REL,      // original of
-        '\u22B7': MO.REL,      // image of
-        '\u22B8': MO.REL,      // multimap
-        '\u22B9': MO.REL,      // hermitian conjugate matrix
-        '\u22BA': MO.BIN4,     // intercalate
-        '\u22BB': MO.BIN4,     // xor
-        '\u22BC': MO.BIN4,     // nand
-        '\u22BD': MO.BIN4,     // nor
-        '\u22BE': MO.BIN3,     // right angle with arc
-        '\u22BF': MO.BIN3,     // right triangle
-        '\u22C7': MO.BIN4,     // division times
-        '\u22C9': MO.BIN4,     // left normal factor semidirect product
-        '\u22CA': MO.BIN4,     // right normal factor semidirect product
-        '\u22CB': MO.BIN4,     // left semidirect product
-        '\u22CC': MO.BIN4,     // right semidirect product
-        '\u22CD': MO.REL,      // reversed tilde equals
-        '\u22CE': MO.BIN4,     // curly logical or
-        '\u22CF': MO.BIN4,     // curly logical and
-        '\u22D0': MO.REL,      // double subset
-        '\u22D1': MO.REL,      // double superset
-        '\u22D2': MO.BIN4,     // double intersection
-        '\u22D3': MO.BIN4,     // double union
-        '\u22D4': MO.REL,      // pitchfork
-        '\u22D5': MO.REL,      // equal and parallel to
-        '\u22D6': MO.REL,      // less-than with dot
-        '\u22D7': MO.REL,      // greater-than with dot
-        '\u22D8': MO.REL,      // very much less-than
-        '\u22D9': MO.REL,      // very much greater-than
-        '\u22DA': MO.REL,      // less-than equal to or greater-than
-        '\u22DB': MO.REL,      // greater-than equal to or less-than
-        '\u22DC': MO.REL,      // equal to or less-than
-        '\u22DD': MO.REL,      // equal to or greater-than
-        '\u22DE': MO.REL,      // equal to or precedes
-        '\u22DF': MO.REL,      // equal to or succeeds
-        '\u22E0': MO.REL,      // does not precede or equal
-        '\u22E1': MO.REL,      // does not succeed or equal
-        '\u22E2': MO.REL,      // not square image of or equal to
-        '\u22E3': MO.REL,      // not square original of or equal to
-        '\u22E4': MO.REL,      // square image of or not equal to
-        '\u22E5': MO.REL,      // square original of or not equal to
-        '\u22E6': MO.REL,      // less-than but not equivalent to
-        '\u22E7': MO.REL,      // greater-than but not equivalent to
-        '\u22E8': MO.REL,      // precedes but not equivalent to
-        '\u22E9': MO.REL,      // succeeds but not equivalent to
-        '\u22EA': MO.REL,      // not normal subgroup of
-        '\u22EB': MO.REL,      // does not contain as normal subgroup
-        '\u22EC': MO.REL,      // not normal subgroup of or equal to
-        '\u22ED': MO.REL,      // does not contain as normal subgroup or equal
-        '\u22F0': MO.REL,      // up right diagonal ellipsis
-        '\u22F2': MO.REL,      // element of with long horizontal stroke
-        '\u22F3': MO.REL,      // element of with vertical bar at end of horizontal stroke
-        '\u22F4': MO.REL,      // small element of with vertical bar at end of horizontal stroke
-        '\u22F5': MO.REL,      // element of with dot above
-        '\u22F6': MO.REL,      // element of with overbar
-        '\u22F7': MO.REL,      // small element of with overbar
-        '\u22F8': MO.REL,      // element of with underbar
-        '\u22F9': MO.REL,      // element of with two horizontal strokes
-        '\u22FA': MO.REL,      // contains with long horizontal stroke
-        '\u22FB': MO.REL,      // contains with vertical bar at end of horizontal stroke
-        '\u22FC': MO.REL,      // small contains with vertical bar at end of horizontal stroke
-        '\u22FD': MO.REL,      // contains with overbar
-        '\u22FE': MO.REL,      // small contains with overbar
-        '\u22FF': MO.REL       // z notation bag membership
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/MathOperators.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/MiscMathSymbolsA.js

@@ -1,38 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u27E6': MO.OPEN      // mathematical left white square bracket
-      },
-      postfix: {
-        '\u27E7': MO.CLOSE     // mathematical right white square bracket
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/MiscMathSymbolsB.js

@@ -1,167 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsB.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u2983': MO.OPEN,     // left white curly bracket
-        '\u2985': MO.OPEN,     // left white parenthesis
-        '\u2987': MO.OPEN,     // z notation left image bracket
-        '\u2989': MO.OPEN,     // z notation left binding bracket
-        '\u298B': MO.OPEN,     // left square bracket with underbar
-        '\u298D': MO.OPEN,     // left square bracket with tick in top corner
-        '\u298F': MO.OPEN,     // left square bracket with tick in bottom corner
-        '\u2991': MO.OPEN,     // left angle bracket with dot
-        '\u2993': MO.OPEN,     // left arc less-than bracket
-        '\u2995': MO.OPEN,     // double left arc greater-than bracket
-        '\u2997': MO.OPEN,     // left black tortoise shell bracket
-        '\u29FC': MO.OPEN      // left-pointing curved angle bracket
-      },
-      postfix: {
-        '\u2984': MO.CLOSE,    // right white curly bracket
-        '\u2986': MO.CLOSE,    // right white parenthesis
-        '\u2988': MO.CLOSE,    // z notation right image bracket
-        '\u298A': MO.CLOSE,    // z notation right binding bracket
-        '\u298C': MO.CLOSE,    // right square bracket with underbar
-        '\u298E': MO.CLOSE,    // right square bracket with tick in bottom corner
-        '\u2990': MO.CLOSE,    // right square bracket with tick in top corner
-        '\u2992': MO.CLOSE,    // right angle bracket with dot
-        '\u2994': MO.CLOSE,    // right arc greater-than bracket
-        '\u2996': MO.CLOSE,    // double right arc less-than bracket
-        '\u2998': MO.CLOSE,    // right black tortoise shell bracket
-        '\u29FD': MO.CLOSE     // right-pointing curved angle bracket
-      },
-      infix: {
-        '\u2980': MO.ORD,      // triple vertical bar delimiter
-        '\u2981': MO.BIN3,     // z notation spot
-        '\u2982': MO.BIN3,     // z notation type colon
-        '\u2999': MO.BIN3,     // dotted fence
-        '\u299A': MO.BIN3,     // vertical zigzag line
-        '\u299B': MO.BIN3,     // measured angle opening left
-        '\u299C': MO.BIN3,     // right angle variant with square
-        '\u299D': MO.BIN3,     // measured right angle with dot
-        '\u299E': MO.BIN3,     // angle with s inside
-        '\u299F': MO.BIN3,     // acute angle
-        '\u29A0': MO.BIN3,     // spherical angle opening left
-        '\u29A1': MO.BIN3,     // spherical angle opening up
-        '\u29A2': MO.BIN3,     // turned angle
-        '\u29A3': MO.BIN3,     // reversed angle
-        '\u29A4': MO.BIN3,     // angle with underbar
-        '\u29A5': MO.BIN3,     // reversed angle with underbar
-        '\u29A6': MO.BIN3,     // oblique angle opening up
-        '\u29A7': MO.BIN3,     // oblique angle opening down
-        '\u29A8': MO.BIN3,     // measured angle with open arm ending in arrow pointing up and right
-        '\u29A9': MO.BIN3,     // measured angle with open arm ending in arrow pointing up and left
-        '\u29AA': MO.BIN3,     // measured angle with open arm ending in arrow pointing down and right
-        '\u29AB': MO.BIN3,     // measured angle with open arm ending in arrow pointing down and left
-        '\u29AC': MO.BIN3,     // measured angle with open arm ending in arrow pointing right and up
-        '\u29AD': MO.BIN3,     // measured angle with open arm ending in arrow pointing left and up
-        '\u29AE': MO.BIN3,     // measured angle with open arm ending in arrow pointing right and down
-        '\u29AF': MO.BIN3,     // measured angle with open arm ending in arrow pointing left and down
-        '\u29B0': MO.BIN3,     // reversed empty set
-        '\u29B1': MO.BIN3,     // empty set with overbar
-        '\u29B2': MO.BIN3,     // empty set with small circle above
-        '\u29B3': MO.BIN3,     // empty set with right arrow above
-        '\u29B4': MO.BIN3,     // empty set with left arrow above
-        '\u29B5': MO.BIN3,     // circle with horizontal bar
-        '\u29B6': MO.BIN4,     // circled vertical bar
-        '\u29B7': MO.BIN4,     // circled parallel
-        '\u29B8': MO.BIN4,     // circled reverse solidus
-        '\u29B9': MO.BIN4,     // circled perpendicular
-        '\u29BA': MO.BIN4,     // circle divided by horizontal bar and top half divided by vertical bar
-        '\u29BB': MO.BIN4,     // circle with superimposed x
-        '\u29BC': MO.BIN4,     // circled anticlockwise-rotated division sign
-        '\u29BD': MO.BIN4,     // up arrow through circle
-        '\u29BE': MO.BIN4,     // circled white bullet
-        '\u29BF': MO.BIN4,     // circled bullet
-        '\u29C0': MO.REL,      // circled less-than
-        '\u29C1': MO.REL,      // circled greater-than
-        '\u29C2': MO.BIN3,     // circle with small circle to the right
-        '\u29C3': MO.BIN3,     // circle with two horizontal strokes to the right
-        '\u29C4': MO.BIN4,     // squared rising diagonal slash
-        '\u29C5': MO.BIN4,     // squared falling diagonal slash
-        '\u29C6': MO.BIN4,     // squared asterisk
-        '\u29C7': MO.BIN4,     // squared small circle
-        '\u29C8': MO.BIN4,     // squared square
-        '\u29C9': MO.BIN3,     // two joined squares
-        '\u29CA': MO.BIN3,     // triangle with dot above
-        '\u29CB': MO.BIN3,     // triangle with underbar
-        '\u29CC': MO.BIN3,     // s in triangle
-        '\u29CD': MO.BIN3,     // triangle with serifs at bottom
-        '\u29CE': MO.REL,      // right triangle above left triangle
-        '\u29CF': MO.REL,      // left triangle beside vertical bar
-        '\u29CF\u0338': MO.BIN4, // left triangle beside vertical bar with slash
-        '\u29D0': MO.REL,      // vertical bar beside right triangle
-        '\u29D0\u0338': MO.BIN4, // vertical bar beside right triangle with slash
-        '\u29D1': MO.REL,      // bowtie with left half black
-        '\u29D2': MO.REL,      // bowtie with right half black
-        '\u29D3': MO.REL,      // black bowtie
-        '\u29D4': MO.REL,      // times with left half black
-        '\u29D5': MO.REL,      // times with right half black
-        '\u29D6': MO.BIN4,     // white hourglass
-        '\u29D7': MO.BIN4,     // black hourglass
-        '\u29D8': MO.BIN3,     // left wiggly fence
-        '\u29D9': MO.BIN3,     // right wiggly fence
-        '\u29DB': MO.BIN3,     // right double wiggly fence
-        '\u29DC': MO.BIN3,     // incomplete infinity
-        '\u29DD': MO.BIN3,     // tie over infinity
-        '\u29DE': MO.REL,      // infinity negated with vertical bar
-        '\u29DF': MO.BIN3,     // double-ended multimap
-        '\u29E0': MO.BIN3,     // square with contoured outline
-        '\u29E1': MO.REL,      // increases as
-        '\u29E2': MO.BIN4,     // shuffle product
-        '\u29E3': MO.REL,      // equals sign and slanted parallel
-        '\u29E4': MO.REL,      // equals sign and slanted parallel with tilde above
-        '\u29E5': MO.REL,      // identical to and slanted parallel
-        '\u29E6': MO.REL,      // gleich stark
-        '\u29E7': MO.BIN3,     // thermodynamic
-        '\u29E8': MO.BIN3,     // down-pointing triangle with left half black
-        '\u29E9': MO.BIN3,     // down-pointing triangle with right half black
-        '\u29EA': MO.BIN3,     // black diamond with down arrow
-        '\u29EB': MO.BIN3,     // black lozenge
-        '\u29EC': MO.BIN3,     // white circle with down arrow
-        '\u29ED': MO.BIN3,     // black circle with down arrow
-        '\u29EE': MO.BIN3,     // error-barred white square
-        '\u29EF': MO.BIN3,     // error-barred black square
-        '\u29F0': MO.BIN3,     // error-barred white diamond
-        '\u29F1': MO.BIN3,     // error-barred black diamond
-        '\u29F2': MO.BIN3,     // error-barred white circle
-        '\u29F3': MO.BIN3,     // error-barred black circle
-        '\u29F4': MO.REL,      // rule-delayed
-        '\u29F5': MO.BIN4,     // reverse solidus operator
-        '\u29F6': MO.BIN4,     // solidus with overbar
-        '\u29F7': MO.BIN4,     // reverse solidus with horizontal stroke
-        '\u29F8': MO.BIN3,     // big solidus
-        '\u29F9': MO.BIN3,     // big reverse solidus
-        '\u29FA': MO.BIN3,     // double plus
-        '\u29FB': MO.BIN3,     // triple plus
-        '\u29FE': MO.BIN4,     // tiny
-        '\u29FF': MO.BIN4      // miny
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsB.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/MiscTechnical.js

@@ -1,38 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '\u23B4': MO.WIDEACCENT, // top square bracket
-        '\u23B5': MO.WIDEACCENT, // bottom square bracket
-        '\u23DC': MO.WIDEACCENT, // top parenthesis
-        '\u23DD': MO.WIDEACCENT  // bottom parenthesis
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/SpacingModLetters.js

@@ -1,36 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      postfix: {
-        '\u02DA': MO.ACCENT,   // ring above
-        '\u02DD': MO.ACCENT    // double acute accent
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/SuppMathOperators.js

@@ -1,289 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      prefix: {
-        '\u2A03': MO.OP,       // n-ary union operator with dot
-        '\u2A05': MO.OP,       // n-ary square intersection operator
-        '\u2A07': MO.OP,       // two logical and operator
-        '\u2A08': MO.OP,       // two logical or operator
-        '\u2A09': MO.OP,       // n-ary times operator
-        '\u2A0A': MO.OP,       // modulo two sum
-        '\u2A0B': MO.INTEGRAL2, // summation with integral
-        '\u2A0C': MO.INTEGRAL, // quadruple integral operator
-        '\u2A0D': MO.INTEGRAL2, // finite part integral
-        '\u2A0E': MO.INTEGRAL2, // integral with double stroke
-        '\u2A0F': MO.INTEGRAL2, // integral average with slash
-        '\u2A10': MO.OP,       // circulation function
-        '\u2A11': MO.OP,       // anticlockwise integration
-        '\u2A12': MO.OP,       // line integration with rectangular path around pole
-        '\u2A13': MO.OP,       // line integration with semicircular path around pole
-        '\u2A14': MO.OP,       // line integration not including the pole
-        '\u2A15': MO.INTEGRAL2, // integral around a point operator
-        '\u2A16': MO.INTEGRAL2, // quaternion integral operator
-        '\u2A17': MO.INTEGRAL2, // integral with leftwards arrow with hook
-        '\u2A18': MO.INTEGRAL2, // integral with times sign
-        '\u2A19': MO.INTEGRAL2, // integral with intersection
-        '\u2A1A': MO.INTEGRAL2, // integral with union
-        '\u2A1B': MO.INTEGRAL2, // integral with overbar
-        '\u2A1C': MO.INTEGRAL2, // integral with underbar
-        '\u2AFC': MO.OP,       // large triple vertical bar operator
-        '\u2AFF': MO.OP        // n-ary white vertical bar
-      },
-      infix: {
-        '\u2A1D': MO.BIN3,     // join
-        '\u2A1E': MO.BIN3,     // large left triangle operator
-        '\u2A1F': MO.BIN3,     // z notation schema composition
-        '\u2A20': MO.BIN3,     // z notation schema piping
-        '\u2A21': MO.BIN3,     // z notation schema projection
-        '\u2A22': MO.BIN4,     // plus sign with small circle above
-        '\u2A23': MO.BIN4,     // plus sign with circumflex accent above
-        '\u2A24': MO.BIN4,     // plus sign with tilde above
-        '\u2A25': MO.BIN4,     // plus sign with dot below
-        '\u2A26': MO.BIN4,     // plus sign with tilde below
-        '\u2A27': MO.BIN4,     // plus sign with subscript two
-        '\u2A28': MO.BIN4,     // plus sign with black triangle
-        '\u2A29': MO.BIN4,     // minus sign with comma above
-        '\u2A2A': MO.BIN4,     // minus sign with dot below
-        '\u2A2B': MO.BIN4,     // minus sign with falling dots
-        '\u2A2C': MO.BIN4,     // minus sign with rising dots
-        '\u2A2D': MO.BIN4,     // plus sign in left half circle
-        '\u2A2E': MO.BIN4,     // plus sign in right half circle
-        '\u2A30': MO.BIN4,     // multiplication sign with dot above
-        '\u2A31': MO.BIN4,     // multiplication sign with underbar
-        '\u2A32': MO.BIN4,     // semidirect product with bottom closed
-        '\u2A33': MO.BIN4,     // smash product
-        '\u2A34': MO.BIN4,     // multiplication sign in left half circle
-        '\u2A35': MO.BIN4,     // multiplication sign in right half circle
-        '\u2A36': MO.BIN4,     // circled multiplication sign with circumflex accent
-        '\u2A37': MO.BIN4,     // multiplication sign in double circle
-        '\u2A38': MO.BIN4,     // circled division sign
-        '\u2A39': MO.BIN4,     // plus sign in triangle
-        '\u2A3A': MO.BIN4,     // minus sign in triangle
-        '\u2A3B': MO.BIN4,     // multiplication sign in triangle
-        '\u2A3C': MO.BIN4,     // interior product
-        '\u2A3D': MO.BIN4,     // righthand interior product
-        '\u2A3E': MO.BIN4,     // z notation relational composition
-        '\u2A40': MO.BIN4,     // intersection with dot
-        '\u2A41': MO.BIN4,     // union with minus sign
-        '\u2A42': MO.BIN4,     // union with overbar
-        '\u2A43': MO.BIN4,     // intersection with overbar
-        '\u2A44': MO.BIN4,     // intersection with logical and
-        '\u2A45': MO.BIN4,     // union with logical or
-        '\u2A46': MO.BIN4,     // union above intersection
-        '\u2A47': MO.BIN4,     // intersection above union
-        '\u2A48': MO.BIN4,     // union above bar above intersection
-        '\u2A49': MO.BIN4,     // intersection above bar above union
-        '\u2A4A': MO.BIN4,     // union beside and joined with union
-        '\u2A4B': MO.BIN4,     // intersection beside and joined with intersection
-        '\u2A4C': MO.BIN4,     // closed union with serifs
-        '\u2A4D': MO.BIN4,     // closed intersection with serifs
-        '\u2A4E': MO.BIN4,     // double square intersection
-        '\u2A4F': MO.BIN4,     // double square union
-        '\u2A50': MO.BIN4,     // closed union with serifs and smash product
-        '\u2A51': MO.BIN4,     // logical and with dot above
-        '\u2A52': MO.BIN4,     // logical or with dot above
-        '\u2A53': MO.BIN4,     // double logical and
-        '\u2A54': MO.BIN4,     // double logical or
-        '\u2A55': MO.BIN4,     // two intersecting logical and
-        '\u2A56': MO.BIN4,     // two intersecting logical or
-        '\u2A57': MO.BIN4,     // sloping large or
-        '\u2A58': MO.BIN4,     // sloping large and
-        '\u2A59': MO.REL,      // logical or overlapping logical and
-        '\u2A5A': MO.BIN4,     // logical and with middle stem
-        '\u2A5B': MO.BIN4,     // logical or with middle stem
-        '\u2A5C': MO.BIN4,     // logical and with horizontal dash
-        '\u2A5D': MO.BIN4,     // logical or with horizontal dash
-        '\u2A5E': MO.BIN4,     // logical and with double overbar
-        '\u2A5F': MO.BIN4,     // logical and with underbar
-        '\u2A60': MO.BIN4,     // logical and with double underbar
-        '\u2A61': MO.BIN4,     // small vee with underbar
-        '\u2A62': MO.BIN4,     // logical or with double overbar
-        '\u2A63': MO.BIN4,     // logical or with double underbar
-        '\u2A64': MO.BIN4,     // z notation domain antirestriction
-        '\u2A65': MO.BIN4,     // z notation range antirestriction
-        '\u2A66': MO.REL,      // equals sign with dot below
-        '\u2A67': MO.REL,      // identical with dot above
-        '\u2A68': MO.REL,      // triple horizontal bar with double vertical stroke
-        '\u2A69': MO.REL,      // triple horizontal bar with triple vertical stroke
-        '\u2A6A': MO.REL,      // tilde operator with dot above
-        '\u2A6B': MO.REL,      // tilde operator with rising dots
-        '\u2A6C': MO.REL,      // similar minus similar
-        '\u2A6D': MO.REL,      // congruent with dot above
-        '\u2A6E': MO.REL,      // equals with asterisk
-        '\u2A6F': MO.REL,      // almost equal to with circumflex accent
-        '\u2A70': MO.REL,      // approximately equal or equal to
-        '\u2A71': MO.BIN4,     // equals sign above plus sign
-        '\u2A72': MO.BIN4,     // plus sign above equals sign
-        '\u2A73': MO.REL,      // equals sign above tilde operator
-        '\u2A74': MO.REL,      // double colon equal
-        '\u2A75': MO.REL,      // two consecutive equals signs
-        '\u2A76': MO.REL,      // three consecutive equals signs
-        '\u2A77': MO.REL,      // equals sign with two dots above and two dots below
-        '\u2A78': MO.REL,      // equivalent with four dots above
-        '\u2A79': MO.REL,      // less-than with circle inside
-        '\u2A7A': MO.REL,      // greater-than with circle inside
-        '\u2A7B': MO.REL,      // less-than with question mark above
-        '\u2A7C': MO.REL,      // greater-than with question mark above
-        '\u2A7D': MO.REL,      // less-than or slanted equal to
-        '\u2A7D\u0338': MO.BIN4, // less-than or slanted equal to with slash
-        '\u2A7E': MO.REL,      // greater-than or slanted equal to
-        '\u2A7E\u0338': MO.BIN4, // greater-than or slanted equal to with slash
-        '\u2A7F': MO.REL,      // less-than or slanted equal to with dot inside
-        '\u2A80': MO.REL,      // greater-than or slanted equal to with dot inside
-        '\u2A81': MO.REL,      // less-than or slanted equal to with dot above
-        '\u2A82': MO.REL,      // greater-than or slanted equal to with dot above
-        '\u2A83': MO.REL,      // less-than or slanted equal to with dot above right
-        '\u2A84': MO.REL,      // greater-than or slanted equal to with dot above left
-        '\u2A85': MO.REL,      // less-than or approximate
-        '\u2A86': MO.REL,      // greater-than or approximate
-        '\u2A87': MO.REL,      // less-than and single-line not equal to
-        '\u2A88': MO.REL,      // greater-than and single-line not equal to
-        '\u2A89': MO.REL,      // less-than and not approximate
-        '\u2A8A': MO.REL,      // greater-than and not approximate
-        '\u2A8B': MO.REL,      // less-than above double-line equal above greater-than
-        '\u2A8C': MO.REL,      // greater-than above double-line equal above less-than
-        '\u2A8D': MO.REL,      // less-than above similar or equal
-        '\u2A8E': MO.REL,      // greater-than above similar or equal
-        '\u2A8F': MO.REL,      // less-than above similar above greater-than
-        '\u2A90': MO.REL,      // greater-than above similar above less-than
-        '\u2A91': MO.REL,      // less-than above greater-than above double-line equal
-        '\u2A92': MO.REL,      // greater-than above less-than above double-line equal
-        '\u2A93': MO.REL,      // less-than above slanted equal above greater-than above slanted equal
-        '\u2A94': MO.REL,      // greater-than above slanted equal above less-than above slanted equal
-        '\u2A95': MO.REL,      // slanted equal to or less-than
-        '\u2A96': MO.REL,      // slanted equal to or greater-than
-        '\u2A97': MO.REL,      // slanted equal to or less-than with dot inside
-        '\u2A98': MO.REL,      // slanted equal to or greater-than with dot inside
-        '\u2A99': MO.REL,      // double-line equal to or less-than
-        '\u2A9A': MO.REL,      // double-line equal to or greater-than
-        '\u2A9B': MO.REL,      // double-line slanted equal to or less-than
-        '\u2A9C': MO.REL,      // double-line slanted equal to or greater-than
-        '\u2A9D': MO.REL,      // similar or less-than
-        '\u2A9E': MO.REL,      // similar or greater-than
-        '\u2A9F': MO.REL,      // similar above less-than above equals sign
-        '\u2AA0': MO.REL,      // similar above greater-than above equals sign
-        '\u2AA1': MO.REL,      // double nested less-than
-        '\u2AA1\u0338': MO.BIN4, // double nested less-than with slash
-        '\u2AA2': MO.REL,      // double nested greater-than
-        '\u2AA2\u0338': MO.BIN4, // double nested greater-than with slash
-        '\u2AA3': MO.REL,      // double nested less-than with underbar
-        '\u2AA4': MO.REL,      // greater-than overlapping less-than
-        '\u2AA5': MO.REL,      // greater-than beside less-than
-        '\u2AA6': MO.REL,      // less-than closed by curve
-        '\u2AA7': MO.REL,      // greater-than closed by curve
-        '\u2AA8': MO.REL,      // less-than closed by curve above slanted equal
-        '\u2AA9': MO.REL,      // greater-than closed by curve above slanted equal
-        '\u2AAA': MO.REL,      // smaller than
-        '\u2AAB': MO.REL,      // larger than
-        '\u2AAC': MO.REL,      // smaller than or equal to
-        '\u2AAD': MO.REL,      // larger than or equal to
-        '\u2AAE': MO.REL,      // equals sign with bumpy above
-        '\u2AAF\u0338': MO.BIN4, // precedes above single-line equals sign with slash
-        '\u2AB0\u0338': MO.BIN4, // succeeds above single-line equals sign with slash
-        '\u2AB1': MO.REL,      // precedes above single-line not equal to
-        '\u2AB2': MO.REL,      // succeeds above single-line not equal to
-        '\u2AB3': MO.REL,      // precedes above equals sign
-        '\u2AB4': MO.REL,      // succeeds above equals sign
-        '\u2AB5': MO.REL,      // precedes above not equal to
-        '\u2AB6': MO.REL,      // succeeds above not equal to
-        '\u2AB7': MO.REL,      // precedes above almost equal to
-        '\u2AB8': MO.REL,      // succeeds above almost equal to
-        '\u2AB9': MO.REL,      // precedes above not almost equal to
-        '\u2ABA': MO.REL,      // succeeds above not almost equal to
-        '\u2ABB': MO.REL,      // double precedes
-        '\u2ABC': MO.REL,      // double succeeds
-        '\u2ABD': MO.REL,      // subset with dot
-        '\u2ABE': MO.REL,      // superset with dot
-        '\u2ABF': MO.REL,      // subset with plus sign below
-        '\u2AC0': MO.REL,      // superset with plus sign below
-        '\u2AC1': MO.REL,      // subset with multiplication sign below
-        '\u2AC2': MO.REL,      // superset with multiplication sign below
-        '\u2AC3': MO.REL,      // subset of or equal to with dot above
-        '\u2AC4': MO.REL,      // superset of or equal to with dot above
-        '\u2AC5': MO.REL,      // subset of above equals sign
-        '\u2AC6': MO.REL,      // superset of above equals sign
-        '\u2AC7': MO.REL,      // subset of above tilde operator
-        '\u2AC8': MO.REL,      // superset of above tilde operator
-        '\u2AC9': MO.REL,      // subset of above almost equal to
-        '\u2ACA': MO.REL,      // superset of above almost equal to
-        '\u2ACB': MO.REL,      // subset of above not equal to
-        '\u2ACC': MO.REL,      // superset of above not equal to
-        '\u2ACD': MO.REL,      // square left open box operator
-        '\u2ACE': MO.REL,      // square right open box operator
-        '\u2ACF': MO.REL,      // closed subset
-        '\u2AD0': MO.REL,      // closed superset
-        '\u2AD1': MO.REL,      // closed subset or equal to
-        '\u2AD2': MO.REL,      // closed superset or equal to
-        '\u2AD3': MO.REL,      // subset above superset
-        '\u2AD4': MO.REL,      // superset above subset
-        '\u2AD5': MO.REL,      // subset above subset
-        '\u2AD6': MO.REL,      // superset above superset
-        '\u2AD7': MO.REL,      // superset beside subset
-        '\u2AD8': MO.REL,      // superset beside and joined by dash with subset
-        '\u2AD9': MO.REL,      // element of opening downwards
-        '\u2ADA': MO.REL,      // pitchfork with tee top
-        '\u2ADB': MO.REL,      // transversal intersection
-        '\u2ADC': MO.REL,      // forking
-        '\u2ADD': MO.REL,      // nonforking
-        '\u2ADE': MO.REL,      // short left tack
-        '\u2ADF': MO.REL,      // short down tack
-        '\u2AE0': MO.REL,      // short up tack
-        '\u2AE1': MO.REL,      // perpendicular with s
-        '\u2AE2': MO.REL,      // vertical bar triple right turnstile
-        '\u2AE3': MO.REL,      // double vertical bar left turnstile
-        '\u2AE4': MO.REL,      // vertical bar double left turnstile
-        '\u2AE5': MO.REL,      // double vertical bar double left turnstile
-        '\u2AE6': MO.REL,      // long dash from left member of double vertical
-        '\u2AE7': MO.REL,      // short down tack with overbar
-        '\u2AE8': MO.REL,      // short up tack with underbar
-        '\u2AE9': MO.REL,      // short up tack above short down tack
-        '\u2AEA': MO.REL,      // double down tack
-        '\u2AEB': MO.REL,      // double up tack
-        '\u2AEC': MO.REL,      // double stroke not sign
-        '\u2AED': MO.REL,      // reversed double stroke not sign
-        '\u2AEE': MO.REL,      // does not divide with reversed negation slash
-        '\u2AEF': MO.REL,      // vertical line with circle above
-        '\u2AF0': MO.REL,      // vertical line with circle below
-        '\u2AF1': MO.REL,      // down tack with circle below
-        '\u2AF2': MO.REL,      // parallel with horizontal stroke
-        '\u2AF3': MO.REL,      // parallel with tilde operator
-        '\u2AF4': MO.BIN4,     // triple vertical bar binary relation
-        '\u2AF5': MO.BIN4,     // triple vertical bar with horizontal stroke
-        '\u2AF6': MO.BIN4,     // triple colon operator
-        '\u2AF7': MO.REL,      // triple nested less-than
-        '\u2AF8': MO.REL,      // triple nested greater-than
-        '\u2AF9': MO.REL,      // double-line slanted less-than or equal to
-        '\u2AFA': MO.REL,      // double-line slanted greater-than or equal to
-        '\u2AFB': MO.BIN4,     // triple solidus binary relation
-        '\u2AFD': MO.BIN4,     // double solidus operator
-        '\u2AFE': MO.BIN3      // white vertical bar
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/SuppMathOperators.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/element/mml/optable/SupplementalArrowsB.js

@@ -1,162 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MML) {
-  var MO = MML.mo.OPTYPES;
-  var TEXCLASS = MML.TEXCLASS;
-
-  MathJax.Hub.Insert(MML.mo.prototype,{
-    OPTABLE: {
-      infix: {
-        '\u2900': MO.REL,      // rightwards two-headed arrow with vertical stroke
-        '\u2901': MO.REL,      // rightwards two-headed arrow with double vertical stroke
-        '\u2902': MO.REL,      // leftwards double arrow with vertical stroke
-        '\u2903': MO.REL,      // rightwards double arrow with vertical stroke
-        '\u2904': MO.REL,      // left right double arrow with vertical stroke
-        '\u2905': MO.REL,      // rightwards two-headed arrow from bar
-        '\u2906': MO.REL,      // leftwards double arrow from bar
-        '\u2907': MO.REL,      // rightwards double arrow from bar
-        '\u2908': MO.REL,      // downwards arrow with horizontal stroke
-        '\u2909': MO.REL,      // upwards arrow with horizontal stroke
-        '\u290A': MO.WIDEREL,  // upwards triple arrow
-        '\u290B': MO.WIDEREL,  // downwards triple arrow
-        '\u290C': MO.WIDEREL,  // leftwards double dash arrow
-        '\u290D': MO.WIDEREL,  // rightwards double dash arrow
-        '\u290E': MO.WIDEREL,  // leftwards triple dash arrow
-        '\u290F': MO.WIDEREL,  // rightwards triple dash arrow
-        '\u2910': MO.WIDEREL,  // rightwards two-headed triple dash arrow
-        '\u2911': MO.REL,      // rightwards arrow with dotted stem
-        '\u2912': MO.WIDEREL,  // upwards arrow to bar
-        '\u2913': MO.WIDEREL,  // downwards arrow to bar
-        '\u2914': MO.REL,      // rightwards arrow with tail with vertical stroke
-        '\u2915': MO.REL,      // rightwards arrow with tail with double vertical stroke
-        '\u2916': MO.REL,      // rightwards two-headed arrow with tail
-        '\u2917': MO.REL,      // rightwards two-headed arrow with tail with vertical stroke
-        '\u2918': MO.REL,      // rightwards two-headed arrow with tail with double vertical stroke
-        '\u2919': MO.REL,      // leftwards arrow-tail
-        '\u291A': MO.REL,      // rightwards arrow-tail
-        '\u291B': MO.REL,      // leftwards double arrow-tail
-        '\u291C': MO.REL,      // rightwards double arrow-tail
-        '\u291D': MO.REL,      // leftwards arrow to black diamond
-        '\u291E': MO.REL,      // rightwards arrow to black diamond
-        '\u291F': MO.REL,      // leftwards arrow from bar to black diamond
-        '\u2920': MO.REL,      // rightwards arrow from bar to black diamond
-        '\u2921': MO.WIDEREL,  // north west and south east arrow
-        '\u2922': MO.WIDEREL,  // north east and south west arrow
-        '\u2923': MO.REL,      // north west arrow with hook
-        '\u2924': MO.REL,      // north east arrow with hook
-        '\u2925': MO.REL,      // south east arrow with hook
-        '\u2926': MO.REL,      // south west arrow with hook
-        '\u2927': MO.REL,      // north west arrow and north east arrow
-        '\u2928': MO.REL,      // north east arrow and south east arrow
-        '\u2929': MO.REL,      // south east arrow and south west arrow
-        '\u292A': MO.REL,      // south west arrow and north west arrow
-        '\u292B': MO.REL,      // rising diagonal crossing falling diagonal
-        '\u292C': MO.REL,      // falling diagonal crossing rising diagonal
-        '\u292D': MO.REL,      // south east arrow crossing north east arrow
-        '\u292E': MO.REL,      // north east arrow crossing south east arrow
-        '\u292F': MO.REL,      // falling diagonal crossing north east arrow
-        '\u2930': MO.REL,      // rising diagonal crossing south east arrow
-        '\u2931': MO.REL,      // north east arrow crossing north west arrow
-        '\u2932': MO.REL,      // north west arrow crossing north east arrow
-        '\u2933': MO.REL,      // wave arrow pointing directly right
-        '\u2934': MO.REL,      // arrow pointing rightwards then curving upwards
-        '\u2935': MO.REL,      // arrow pointing rightwards then curving downwards
-        '\u2936': MO.REL,      // arrow pointing downwards then curving leftwards
-        '\u2937': MO.REL,      // arrow pointing downwards then curving rightwards
-        '\u2938': MO.REL,      // right-side arc clockwise arrow
-        '\u2939': MO.REL,      // left-side arc anticlockwise arrow
-        '\u293A': MO.REL,      // top arc anticlockwise arrow
-        '\u293B': MO.REL,      // bottom arc anticlockwise arrow
-        '\u293C': MO.REL,      // top arc clockwise arrow with minus
-        '\u293D': MO.REL,      // top arc anticlockwise arrow with plus
-        '\u293E': MO.REL,      // lower right semicircular clockwise arrow
-        '\u293F': MO.REL,      // lower left semicircular anticlockwise arrow
-        '\u2940': MO.REL,      // anticlockwise closed circle arrow
-        '\u2941': MO.REL,      // clockwise closed circle arrow
-        '\u2942': MO.REL,      // rightwards arrow above short leftwards arrow
-        '\u2943': MO.REL,      // leftwards arrow above short rightwards arrow
-        '\u2944': MO.REL,      // short rightwards arrow above leftwards arrow
-        '\u2945': MO.REL,      // rightwards arrow with plus below
-        '\u2946': MO.REL,      // leftwards arrow with plus below
-        '\u2947': MO.REL,      // rightwards arrow through x
-        '\u2948': MO.REL,      // left right arrow through small circle
-        '\u2949': MO.REL,      // upwards two-headed arrow from small circle
-        '\u294A': MO.REL,      // left barb up right barb down harpoon
-        '\u294B': MO.REL,      // left barb down right barb up harpoon
-        '\u294C': MO.REL,      // up barb right down barb left harpoon
-        '\u294D': MO.REL,      // up barb left down barb right harpoon
-        '\u294E': MO.RELACCENT, // left barb up right barb up harpoon
-        '\u294F': MO.WIDEREL,  // up barb right down barb right harpoon
-        '\u2950': MO.WIDEREL,  // left barb down right barb down harpoon
-        '\u2951': MO.WIDEREL,  // up barb left down barb left harpoon
-        '\u2952': MO.WIDEREL,  // leftwards harpoon with barb up to bar
-        '\u2953': MO.WIDEREL,  // rightwards harpoon with barb up to bar
-        '\u2954': MO.WIDEREL,  // upwards harpoon with barb right to bar
-        '\u2955': MO.WIDEREL,  // downwards harpoon with barb right to bar
-        '\u2956': MO.WIDEREL,  // leftwards harpoon with barb down to bar
-        '\u2957': MO.WIDEREL,  // rightwards harpoon with barb down to bar
-        '\u2958': MO.WIDEREL,  // upwards harpoon with barb left to bar
-        '\u2959': MO.WIDEREL,  // downwards harpoon with barb left to bar
-        '\u295A': MO.WIDEREL,  // leftwards harpoon with barb up from bar
-        '\u295B': MO.WIDEREL,  // rightwards harpoon with barb up from bar
-        '\u295C': MO.WIDEREL,  // upwards harpoon with barb right from bar
-        '\u295D': MO.WIDEREL,  // downwards harpoon with barb right from bar
-        '\u295E': MO.WIDEREL,  // leftwards harpoon with barb down from bar
-        '\u295F': MO.WIDEREL,  // rightwards harpoon with barb down from bar
-        '\u2960': MO.WIDEREL,  // upwards harpoon with barb left from bar
-        '\u2961': MO.WIDEREL,  // downwards harpoon with barb left from bar
-        '\u2962': MO.REL,      // leftwards harpoon with barb up above leftwards harpoon with barb down
-        '\u2963': MO.REL,      // upwards harpoon with barb left beside upwards harpoon with barb right
-        '\u2964': MO.REL,      // rightwards harpoon with barb up above rightwards harpoon with barb down
-        '\u2965': MO.REL,      // downwards harpoon with barb left beside downwards harpoon with barb right
-        '\u2966': MO.REL,      // leftwards harpoon with barb up above rightwards harpoon with barb up
-        '\u2967': MO.REL,      // leftwards harpoon with barb down above rightwards harpoon with barb down
-        '\u2968': MO.REL,      // rightwards harpoon with barb up above leftwards harpoon with barb up
-        '\u2969': MO.REL,      // rightwards harpoon with barb down above leftwards harpoon with barb down
-        '\u296A': MO.REL,      // leftwards harpoon with barb up above long dash
-        '\u296B': MO.REL,      // leftwards harpoon with barb down below long dash
-        '\u296C': MO.REL,      // rightwards harpoon with barb up above long dash
-        '\u296D': MO.REL,      // rightwards harpoon with barb down below long dash
-        '\u296E': MO.WIDEREL,  // upwards harpoon with barb left beside downwards harpoon with barb right
-        '\u296F': MO.WIDEREL,  // downwards harpoon with barb left beside upwards harpoon with barb right
-        '\u2970': MO.REL,      // right double arrow with rounded head
-        '\u2971': MO.REL,      // equals sign above rightwards arrow
-        '\u2972': MO.REL,      // tilde operator above rightwards arrow
-        '\u2973': MO.REL,      // leftwards arrow above tilde operator
-        '\u2974': MO.REL,      // rightwards arrow above tilde operator
-        '\u2975': MO.REL,      // rightwards arrow above almost equal to
-        '\u2976': MO.REL,      // less-than above leftwards arrow
-        '\u2977': MO.REL,      // leftwards arrow through less-than
-        '\u2978': MO.REL,      // greater-than above rightwards arrow
-        '\u2979': MO.REL,      // subset above rightwards arrow
-        '\u297A': MO.REL,      // leftwards arrow through subset
-        '\u297B': MO.REL,      // superset above leftwards arrow
-        '\u297C': MO.REL,      // left fish tail
-        '\u297D': MO.REL,      // right fish tail
-        '\u297E': MO.REL,      // up fish tail
-        '\u297F': MO.REL       // down fish tail
-      }
-    }
-  });
-
-  MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js");
-
-})(MathJax.ElementJax.mml);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/config.js

@@ -1,39 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/input/MathML/config.js
- *
- *  Initializes the MathML InputJax (the main definition is in
- *  MathJax/jax/input/MathML/jax.js, which is loaded when needed).
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.InputJax.MathML = MathJax.InputJax({
-  name: "MathML",
-  version: 1.0,
-  directory: MathJax.InputJax.directory + "/MathML",
-  extensionDir: MathJax.InputJax.extensionDir + "/MathML",
-  entityDir: MathJax.InputJax.directory + "/MathML/entities",
-  require: [MathJax.ElementJax.directory + "/mml/jax.js"],
-  
-  config: {
-    useMathMLspacing: false         // false means use TeX spacing, true means MML spacing
-  }
-});
-MathJax.InputJax.MathML.Register("math/mml");
-
-MathJax.InputJax.MathML.loadComplete("config.js");

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/a.js

@@ -1,87 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/a.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'AElig': '\u00C6',
-    'Aacute': '\u00C1',
-    'Abreve': '\u0102',
-    'Acirc': '\u00C2',
-    'Acy': '\u0410',
-    'Agrave': '\u00C0',
-    'Amacr': '\u0100',
-    'And': '\u2A53',
-    'Aogon': '\u0104',
-    'Aring': '\u00C5',
-    'Assign': '\u2254',
-    'Atilde': '\u00C3',
-    'Auml': '\u00C4',
-    'aacute': '\u00E1',
-    'abreve': '\u0103',
-    'ac': '\u223E',
-    'acE': '\u223E\u0333',
-    'acd': '\u223F',
-    'acirc': '\u00E2',
-    'acy': '\u0430',
-    'aelig': '\u00E6',
-    'af': '\u2061',
-    'agrave': '\u00E0',
-    'amacr': '\u0101',
-    'amp': '\u0026',
-    'andand': '\u2A55',
-    'andd': '\u2A5C',
-    'andslope': '\u2A58',
-    'andv': '\u2A5A',
-    'ange': '\u29A4',
-    'angle': '\u2220',
-    'angmsdaa': '\u29A8',
-    'angmsdab': '\u29A9',
-    'angmsdac': '\u29AA',
-    'angmsdad': '\u29AB',
-    'angmsdae': '\u29AC',
-    'angmsdaf': '\u29AD',
-    'angmsdag': '\u29AE',
-    'angmsdah': '\u29AF',
-    'angrt': '\u221F',
-    'angrtvb': '\u22BE',
-    'angrtvbd': '\u299D',
-    'angst': '\u212B',
-    'angzarr': '\u237C',
-    'aogon': '\u0105',
-    'ap': '\u2248',
-    'apE': '\u2A70',
-    'apacir': '\u2A6F',
-    'apid': '\u224B',
-    'apos': '\u0027',
-    'approx': '\u2248',
-    'approxeq': '\u224A',
-    'aring': '\u00E5',
-    'ast': '\u002A',
-    'asymp': '\u2248',
-    'asympeq': '\u224D',
-    'atilde': '\u00E3',
-    'auml': '\u00E4',
-    'awconint': '\u2233',
-    'awint': '\u2A11'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/a.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/b.js

@@ -1,114 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/b.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Barv': '\u2AE7',
-    'Barwed': '\u2306',
-    'Bcy': '\u0411',
-    'Bernoullis': '\u212C',
-    'Bumpeq': '\u224E',
-    'bNot': '\u2AED',
-    'backcong': '\u224C',
-    'backepsilon': '\u03F6',
-    'barvee': '\u22BD',
-    'barwed': '\u2305',
-    'barwedge': '\u2305',
-    'bbrk': '\u23B5',
-    'bbrktbrk': '\u23B6',
-    'bcong': '\u224C',
-    'bcy': '\u0431',
-    'becaus': '\u2235',
-    'because': '\u2235',
-    'bemptyv': '\u29B0',
-    'bepsi': '\u03F6',
-    'bernou': '\u212C',
-    'bigcap': '\u22C2',
-    'bigcup': '\u22C3',
-    'bigvee': '\u22C1',
-    'bigwedge': '\u22C0',
-    'bkarow': '\u290D',
-    'blacksquare': '\u25AA',
-    'blacktriangleright': '\u25B8',
-    'blank': '\u2423',
-    'blk12': '\u2592',
-    'blk14': '\u2591',
-    'blk34': '\u2593',
-    'block': '\u2588',
-    'bne': '\u003D\u20E5',
-    'bnequiv': '\u2261\u20E5',
-    'bnot': '\u2310',
-    'bot': '\u22A5',
-    'bottom': '\u22A5',
-    'boxDL': '\u2557',
-    'boxDR': '\u2554',
-    'boxDl': '\u2556',
-    'boxDr': '\u2553',
-    'boxH': '\u2550',
-    'boxHD': '\u2566',
-    'boxHU': '\u2569',
-    'boxHd': '\u2564',
-    'boxHu': '\u2567',
-    'boxUL': '\u255D',
-    'boxUR': '\u255A',
-    'boxUl': '\u255C',
-    'boxUr': '\u2559',
-    'boxV': '\u2551',
-    'boxVH': '\u256C',
-    'boxVL': '\u2563',
-    'boxVR': '\u2560',
-    'boxVh': '\u256B',
-    'boxVl': '\u2562',
-    'boxVr': '\u255F',
-    'boxbox': '\u29C9',
-    'boxdL': '\u2555',
-    'boxdR': '\u2552',
-    'boxh': '\u2500',
-    'boxhD': '\u2565',
-    'boxhU': '\u2568',
-    'boxhd': '\u252C',
-    'boxhu': '\u2534',
-    'boxuL': '\u255B',
-    'boxuR': '\u2558',
-    'boxv': '\u2502',
-    'boxvH': '\u256A',
-    'boxvL': '\u2561',
-    'boxvR': '\u255E',
-    'boxvh': '\u253C',
-    'boxvl': '\u2524',
-    'boxvr': '\u251C',
-    'bprime': '\u2035',
-    'breve': '\u02D8',
-    'brvbar': '\u00A6',
-    'bsemi': '\u204F',
-    'bsim': '\u223D',
-    'bsime': '\u22CD',
-    'bsolb': '\u29C5',
-    'bsolhsub': '\u005C\u2282',
-    'bullet': '\u2022',
-    'bump': '\u224E',
-    'bumpE': '\u2AAE',
-    'bumpe': '\u224F',
-    'bumpeq': '\u224F'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/b.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/c.js

@@ -1,111 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/c.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'CHcy': '\u0427',
-    'Cacute': '\u0106',
-    'CapitalDifferentialD': '\u2145',
-    'Cayleys': '\u212D',
-    'Ccaron': '\u010C',
-    'Ccedil': '\u00C7',
-    'Ccirc': '\u0108',
-    'Cconint': '\u2230',
-    'Cdot': '\u010A',
-    'Cedilla': '\u00B8',
-    'ClockwiseContourIntegral': '\u2232',
-    'CloseCurlyDoubleQuote': '\u201D',
-    'CloseCurlyQuote': '\u2019',
-    'Colon': '\u2237',
-    'Colone': '\u2A74',
-    'Conint': '\u222F',
-    'CounterClockwiseContourIntegral': '\u2233',
-    'cacute': '\u0107',
-    'capand': '\u2A44',
-    'capbrcup': '\u2A49',
-    'capcap': '\u2A4B',
-    'capcup': '\u2A47',
-    'capdot': '\u2A40',
-    'caps': '\u2229\uFE00',
-    'caret': '\u2041',
-    'caron': '\u02C7',
-    'ccaps': '\u2A4D',
-    'ccaron': '\u010D',
-    'ccedil': '\u00E7',
-    'ccirc': '\u0109',
-    'ccups': '\u2A4C',
-    'ccupssm': '\u2A50',
-    'cdot': '\u010B',
-    'cedil': '\u00B8',
-    'cemptyv': '\u29B2',
-    'cent': '\u00A2',
-    'centerdot': '\u00B7',
-    'chcy': '\u0447',
-    'checkmark': '\u2713',
-    'cir': '\u25CB',
-    'cirE': '\u29C3',
-    'cire': '\u2257',
-    'cirfnint': '\u2A10',
-    'cirmid': '\u2AEF',
-    'cirscir': '\u29C2',
-    'clubsuit': '\u2663',
-    'colone': '\u2254',
-    'coloneq': '\u2254',
-    'comma': '\u002C',
-    'commat': '\u0040',
-    'compfn': '\u2218',
-    'complement': '\u2201',
-    'complexes': '\u2102',
-    'cong': '\u2245',
-    'congdot': '\u2A6D',
-    'conint': '\u222E',
-    'coprod': '\u2210',
-    'copy': '\u00A9',
-    'copysr': '\u2117',
-    'cross': '\u2717',
-    'csub': '\u2ACF',
-    'csube': '\u2AD1',
-    'csup': '\u2AD0',
-    'csupe': '\u2AD2',
-    'cudarrl': '\u2938',
-    'cudarrr': '\u2935',
-    'cularrp': '\u293D',
-    'cupbrcap': '\u2A48',
-    'cupcap': '\u2A46',
-    'cupcup': '\u2A4A',
-    'cupdot': '\u228D',
-    'cupor': '\u2A45',
-    'cups': '\u222A\uFE00',
-    'curarrm': '\u293C',
-    'curlyeqprec': '\u22DE',
-    'curlyeqsucc': '\u22DF',
-    'curren': '\u00A4',
-    'curvearrowleft': '\u21B6',
-    'curvearrowright': '\u21B7',
-    'cuvee': '\u22CE',
-    'cuwed': '\u22CF',
-    'cwconint': '\u2232',
-    'cwint': '\u2231',
-    'cylcty': '\u232D'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/c.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/d.js

@@ -1,112 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/d.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'DD': '\u2145',
-    'DDotrahd': '\u2911',
-    'DJcy': '\u0402',
-    'DScy': '\u0405',
-    'DZcy': '\u040F',
-    'Darr': '\u21A1',
-    'Dashv': '\u2AE4',
-    'Dcaron': '\u010E',
-    'Dcy': '\u0414',
-    'DiacriticalAcute': '\u00B4',
-    'DiacriticalDot': '\u02D9',
-    'DiacriticalDoubleAcute': '\u02DD',
-    'DiacriticalGrave': '\u0060',
-    'DiacriticalTilde': '\u02DC',
-    'Dot': '\u00A8',
-    'DotDot': '\u20DC',
-    'DoubleContourIntegral': '\u222F',
-    'DoubleDownArrow': '\u21D3',
-    'DoubleLeftArrow': '\u21D0',
-    'DoubleLeftRightArrow': '\u21D4',
-    'DoubleLeftTee': '\u2AE4',
-    'DoubleLongLeftArrow': '\u27F8',
-    'DoubleLongLeftRightArrow': '\u27FA',
-    'DoubleLongRightArrow': '\u27F9',
-    'DoubleRightArrow': '\u21D2',
-    'DoubleUpArrow': '\u21D1',
-    'DoubleUpDownArrow': '\u21D5',
-    'DownArrowBar': '\u2913',
-    'DownArrowUpArrow': '\u21F5',
-    'DownBreve': '\u0311',
-    'DownLeftRightVector': '\u2950',
-    'DownLeftTeeVector': '\u295E',
-    'DownLeftVectorBar': '\u2956',
-    'DownRightTeeVector': '\u295F',
-    'DownRightVectorBar': '\u2957',
-    'DownTeeArrow': '\u21A7',
-    'Dstrok': '\u0110',
-    'dArr': '\u21D3',
-    'dHar': '\u2965',
-    'darr': '\u2193',
-    'dash': '\u2010',
-    'dashv': '\u22A3',
-    'dbkarow': '\u290F',
-    'dblac': '\u02DD',
-    'dcaron': '\u010F',
-    'dcy': '\u0434',
-    'dd': '\u2146',
-    'ddagger': '\u2021',
-    'ddotseq': '\u2A77',
-    'demptyv': '\u29B1',
-    'dfisht': '\u297F',
-    'dharl': '\u21C3',
-    'dharr': '\u21C2',
-    'diam': '\u22C4',
-    'diamond': '\u22C4',
-    'diamondsuit': '\u2666',
-    'diams': '\u2666',
-    'die': '\u00A8',
-    'disin': '\u22F2',
-    'divide': '\u00F7',
-    'divonx': '\u22C7',
-    'djcy': '\u0452',
-    'dlcorn': '\u231E',
-    'dlcrop': '\u230D',
-    'dollar': '\u0024',
-    'doteq': '\u2250',
-    'dotminus': '\u2238',
-    'doublebarwedge': '\u2306',
-    'downarrow': '\u2193',
-    'downdownarrows': '\u21CA',
-    'downharpoonleft': '\u21C3',
-    'downharpoonright': '\u21C2',
-    'drbkarow': '\u2910',
-    'drcorn': '\u231F',
-    'drcrop': '\u230C',
-    'dscy': '\u0455',
-    'dsol': '\u29F6',
-    'dstrok': '\u0111',
-    'dtri': '\u25BF',
-    'dtrif': '\u25BE',
-    'duarr': '\u21F5',
-    'duhar': '\u296F',
-    'dwangle': '\u29A6',
-    'dzcy': '\u045F',
-    'dzigrarr': '\u27FF'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/d.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/e.js

@@ -1,88 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/e.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'ENG': '\u014A',
-    'ETH': '\u00D0',
-    'Eacute': '\u00C9',
-    'Ecaron': '\u011A',
-    'Ecirc': '\u00CA',
-    'Ecy': '\u042D',
-    'Edot': '\u0116',
-    'Egrave': '\u00C8',
-    'Emacr': '\u0112',
-    'EmptySmallSquare': '\u25FB',
-    'EmptyVerySmallSquare': '\u25AB',
-    'Eogon': '\u0118',
-    'Equal': '\u2A75',
-    'Esim': '\u2A73',
-    'Euml': '\u00CB',
-    'eDDot': '\u2A77',
-    'eDot': '\u2251',
-    'eacute': '\u00E9',
-    'easter': '\u2A6E',
-    'ecaron': '\u011B',
-    'ecirc': '\u00EA',
-    'ecolon': '\u2255',
-    'ecy': '\u044D',
-    'edot': '\u0117',
-    'ee': '\u2147',
-    'eg': '\u2A9A',
-    'egrave': '\u00E8',
-    'egsdot': '\u2A98',
-    'el': '\u2A99',
-    'elinters': '\uFFFD',
-    'elsdot': '\u2A97',
-    'emacr': '\u0113',
-    'emptyset': '\u2205',
-    'emptyv': '\u2205',
-    'emsp': '\u2003',
-    'emsp13': '\u2004',
-    'emsp14': '\u2005',
-    'eng': '\u014B',
-    'ensp': '\u2002',
-    'eogon': '\u0119',
-    'epar': '\u22D5',
-    'eparsl': '\u29E3',
-    'eplus': '\u2A71',
-    'eqcirc': '\u2256',
-    'eqcolon': '\u2255',
-    'eqsim': '\u2242',
-    'eqslantgtr': '\u2A96',
-    'eqslantless': '\u2A95',
-    'equals': '\u003D',
-    'equest': '\u225F',
-    'equiv': '\u2261',
-    'equivDD': '\u2A78',
-    'eqvparsl': '\u29E5',
-    'erarr': '\u2971',
-    'esdot': '\u2250',
-    'esim': '\u2242',
-    'euml': '\u00EB',
-    'excl': '\u0021',
-    'exist': '\u2203',
-    'expectation': '\u2130',
-    'exponentiale': '\u2147'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/e.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/f.js

@@ -1,58 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/f.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Fcy': '\u0424',
-    'FilledSmallSquare': '\u25FC',
-    'Fouriertrf': '\u2131',
-    'fallingdotseq': '\u2252',
-    'fcy': '\u0444',
-    'female': '\u2640',
-    'ffilig': '\uFB03',
-    'fflig': '\uFB00',
-    'ffllig': '\uFB04',
-    'filig': '\uFB01',
-    'fllig': '\uFB02',
-    'fltns': '\u25B1',
-    'fnof': '\u0192',
-    'forall': '\u2200',
-    'forkv': '\u2AD9',
-    'fpartint': '\u2A0D',
-    'frac12': '\u00BD',
-    'frac13': '\u2153',
-    'frac14': '\u00BC',
-    'frac15': '\u2155',
-    'frac16': '\u2159',
-    'frac18': '\u215B',
-    'frac23': '\u2154',
-    'frac25': '\u2156',
-    'frac34': '\u00BE',
-    'frac35': '\u2157',
-    'frac38': '\u215C',
-    'frac45': '\u2158',
-    'frac56': '\u215A',
-    'frac58': '\u215D',
-    'frac78': '\u215E'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/f.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/fr.js

@@ -1,79 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/fr.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Afr': '\uD835\uDD04',
-    'Bfr': '\uD835\uDD05',
-    'Cfr': '\u212D',
-    'Dfr': '\uD835\uDD07',
-    'Efr': '\uD835\uDD08',
-    'Ffr': '\uD835\uDD09',
-    'Gfr': '\uD835\uDD0A',
-    'Hfr': '\u210C',
-    'Ifr': '\u2111',
-    'Jfr': '\uD835\uDD0D',
-    'Kfr': '\uD835\uDD0E',
-    'Lfr': '\uD835\uDD0F',
-    'Mfr': '\uD835\uDD10',
-    'Nfr': '\uD835\uDD11',
-    'Ofr': '\uD835\uDD12',
-    'Pfr': '\uD835\uDD13',
-    'Qfr': '\uD835\uDD14',
-    'Rfr': '\u211C',
-    'Sfr': '\uD835\uDD16',
-    'Tfr': '\uD835\uDD17',
-    'Ufr': '\uD835\uDD18',
-    'Vfr': '\uD835\uDD19',
-    'Wfr': '\uD835\uDD1A',
-    'Xfr': '\uD835\uDD1B',
-    'Yfr': '\uD835\uDD1C',
-    'Zfr': '\u2128',
-    'afr': '\uD835\uDD1E',
-    'bfr': '\uD835\uDD1F',
-    'cfr': '\uD835\uDD20',
-    'dfr': '\uD835\uDD21',
-    'efr': '\uD835\uDD22',
-    'ffr': '\uD835\uDD23',
-    'gfr': '\uD835\uDD24',
-    'hfr': '\uD835\uDD25',
-    'ifr': '\uD835\uDD26',
-    'jfr': '\uD835\uDD27',
-    'kfr': '\uD835\uDD28',
-    'lfr': '\uD835\uDD29',
-    'mfr': '\uD835\uDD2A',
-    'nfr': '\uD835\uDD2B',
-    'ofr': '\uD835\uDD2C',
-    'pfr': '\uD835\uDD2D',
-    'qfr': '\uD835\uDD2E',
-    'rfr': '\uD835\uDD2F',
-    'sfr': '\uD835\uDD30',
-    'tfr': '\uD835\uDD31',
-    'ufr': '\uD835\uDD32',
-    'vfr': '\uD835\uDD33',
-    'wfr': '\uD835\uDD34',
-    'xfr': '\uD835\uDD35',
-    'yfr': '\uD835\uDD36',
-    'zfr': '\uD835\uDD37'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/fr.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/g.js

@@ -1,82 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/g.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'GJcy': '\u0403',
-    'Gammad': '\u03DC',
-    'Gbreve': '\u011E',
-    'Gcedil': '\u0122',
-    'Gcirc': '\u011C',
-    'Gcy': '\u0413',
-    'Gdot': '\u0120',
-    'GreaterGreater': '\u2AA2',
-    'Gt': '\u226B',
-    'gE': '\u2267',
-    'gacute': '\u01F5',
-    'gammad': '\u03DD',
-    'gbreve': '\u011F',
-    'gcirc': '\u011D',
-    'gcy': '\u0433',
-    'gdot': '\u0121',
-    'ge': '\u2265',
-    'gel': '\u22DB',
-    'geq': '\u2265',
-    'geqq': '\u2267',
-    'geqslant': '\u2A7E',
-    'ges': '\u2A7E',
-    'gescc': '\u2AA9',
-    'gesdot': '\u2A80',
-    'gesdoto': '\u2A82',
-    'gesdotol': '\u2A84',
-    'gesl': '\u22DB\uFE00',
-    'gesles': '\u2A94',
-    'gg': '\u226B',
-    'ggg': '\u22D9',
-    'gjcy': '\u0453',
-    'gl': '\u2277',
-    'glE': '\u2A92',
-    'gla': '\u2AA5',
-    'glj': '\u2AA4',
-    'gnapprox': '\u2A8A',
-    'gneq': '\u2A88',
-    'gneqq': '\u2269',
-    'grave': '\u0060',
-    'gsim': '\u2273',
-    'gsime': '\u2A8E',
-    'gsiml': '\u2A90',
-    'gtcc': '\u2AA7',
-    'gtcir': '\u2A7A',
-    'gtlPar': '\u2995',
-    'gtquest': '\u2A7C',
-    'gtrapprox': '\u2A86',
-    'gtrarr': '\u2978',
-    'gtrdot': '\u22D7',
-    'gtreqless': '\u22DB',
-    'gtreqqless': '\u2A8C',
-    'gtrless': '\u2277',
-    'gtrsim': '\u2273',
-    'gvertneqq': '\u2269\uFE00',
-    'gvnE': '\u2269\uFE00'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/g.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/h.js

@@ -1,52 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/h.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'HARDcy': '\u042A',
-    'Hcirc': '\u0124',
-    'HilbertSpace': '\u210B',
-    'HorizontalLine': '\u2500',
-    'Hstrok': '\u0126',
-    'hArr': '\u21D4',
-    'hairsp': '\u200A',
-    'half': '\u00BD',
-    'hamilt': '\u210B',
-    'hardcy': '\u044A',
-    'harr': '\u2194',
-    'harrcir': '\u2948',
-    'hcirc': '\u0125',
-    'hearts': '\u2665',
-    'heartsuit': '\u2665',
-    'hercon': '\u22B9',
-    'hksearow': '\u2925',
-    'hkswarow': '\u2926',
-    'hoarr': '\u21FF',
-    'homtht': '\u223B',
-    'horbar': '\u2015',
-    'hslash': '\u210F',
-    'hstrok': '\u0127',
-    'hybull': '\u2043',
-    'hyphen': '\u2010'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/h.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/i.js

@@ -1,85 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/i.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'IEcy': '\u0415',
-    'IJlig': '\u0132',
-    'IOcy': '\u0401',
-    'Iacute': '\u00CD',
-    'Icirc': '\u00CE',
-    'Icy': '\u0418',
-    'Idot': '\u0130',
-    'Igrave': '\u00CC',
-    'Imacr': '\u012A',
-    'Implies': '\u21D2',
-    'Int': '\u222C',
-    'Iogon': '\u012E',
-    'Itilde': '\u0128',
-    'Iukcy': '\u0406',
-    'Iuml': '\u00CF',
-    'iacute': '\u00ED',
-    'ic': '\u2063',
-    'icirc': '\u00EE',
-    'icy': '\u0438',
-    'iecy': '\u0435',
-    'iexcl': '\u00A1',
-    'iff': '\u21D4',
-    'igrave': '\u00EC',
-    'ii': '\u2148',
-    'iiiint': '\u2A0C',
-    'iiint': '\u222D',
-    'iinfin': '\u29DC',
-    'iiota': '\u2129',
-    'ijlig': '\u0133',
-    'imacr': '\u012B',
-    'image': '\u2111',
-    'imagline': '\u2110',
-    'imagpart': '\u2111',
-    'imof': '\u22B7',
-    'imped': '\u01B5',
-    'in': '\u2208',
-    'incare': '\u2105',
-    'infintie': '\u29DD',
-    'inodot': '\u0131',
-    'int': '\u222B',
-    'integers': '\u2124',
-    'intercal': '\u22BA',
-    'intlarhk': '\u2A17',
-    'intprod': '\u2A3C',
-    'iocy': '\u0451',
-    'iogon': '\u012F',
-    'iprod': '\u2A3C',
-    'iquest': '\u00BF',
-    'isin': '\u2208',
-    'isinE': '\u22F9',
-    'isindot': '\u22F5',
-    'isins': '\u22F4',
-    'isinsv': '\u22F3',
-    'isinv': '\u2208',
-    'it': '\u2062',
-    'itilde': '\u0129',
-    'iukcy': '\u0456',
-    'iuml': '\u00EF'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/i.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/j.js

@@ -1,36 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/j.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Jcirc': '\u0134',
-    'Jcy': '\u0419',
-    'Jsercy': '\u0408',
-    'Jukcy': '\u0404',
-    'jcirc': '\u0135',
-    'jcy': '\u0439',
-    'jmath': '\u006A',
-    'jsercy': '\u0458',
-    'jukcy': '\u0454'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/j.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/k.js

@@ -1,36 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/k.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'KHcy': '\u0425',
-    'KJcy': '\u040C',
-    'Kcedil': '\u0136',
-    'Kcy': '\u041A',
-    'kcedil': '\u0137',
-    'kcy': '\u043A',
-    'kgreen': '\u0138',
-    'khcy': '\u0445',
-    'kjcy': '\u045C'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/k.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/l.js

@@ -1,175 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/l.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'LJcy': '\u0409',
-    'Lacute': '\u0139',
-    'Lang': '\u300A',
-    'Laplacetrf': '\u2112',
-    'Lcaron': '\u013D',
-    'Lcedil': '\u013B',
-    'Lcy': '\u041B',
-    'LeftArrowBar': '\u21E4',
-    'LeftDoubleBracket': '\u301A',
-    'LeftDownTeeVector': '\u2961',
-    'LeftDownVectorBar': '\u2959',
-    'LeftRightVector': '\u294E',
-    'LeftTeeArrow': '\u21A4',
-    'LeftTeeVector': '\u295A',
-    'LeftTriangleBar': '\u29CF',
-    'LeftUpDownVector': '\u2951',
-    'LeftUpTeeVector': '\u2960',
-    'LeftUpVectorBar': '\u2958',
-    'LeftVectorBar': '\u2952',
-    'LessLess': '\u2AA1',
-    'Lmidot': '\u013F',
-    'LowerLeftArrow': '\u2199',
-    'LowerRightArrow': '\u2198',
-    'Lstrok': '\u0141',
-    'Lt': '\u226A',
-    'lAarr': '\u21DA',
-    'lArr': '\u21D0',
-    'lAtail': '\u291B',
-    'lBarr': '\u290E',
-    'lE': '\u2266',
-    'lHar': '\u2962',
-    'lacute': '\u013A',
-    'laemptyv': '\u29B4',
-    'lagran': '\u2112',
-    'lang': '\u2329',
-    'langd': '\u2991',
-    'langle': '\u2329',
-    'laquo': '\u00AB',
-    'larr': '\u2190',
-    'larrb': '\u21E4',
-    'larrbfs': '\u291F',
-    'larrfs': '\u291D',
-    'larrhk': '\u21A9',
-    'larrpl': '\u2939',
-    'larrsim': '\u2973',
-    'lat': '\u2AAB',
-    'latail': '\u2919',
-    'late': '\u2AAD',
-    'lates': '\u2AAD\uFE00',
-    'lbarr': '\u290C',
-    'lbbrk': '\u3014',
-    'lbrke': '\u298B',
-    'lbrksld': '\u298F',
-    'lbrkslu': '\u298D',
-    'lcaron': '\u013E',
-    'lcedil': '\u013C',
-    'lceil': '\u2308',
-    'lcub': '\u007B',
-    'lcy': '\u043B',
-    'ldca': '\u2936',
-    'ldquo': '\u201C',
-    'ldquor': '\u201E',
-    'ldrdhar': '\u2967',
-    'ldrushar': '\u294B',
-    'ldsh': '\u21B2',
-    'leftarrow': '\u2190',
-    'leftarrowtail': '\u21A2',
-    'leftharpoondown': '\u21BD',
-    'leftharpoonup': '\u21BC',
-    'leftrightarrow': '\u2194',
-    'leftrightarrows': '\u21C6',
-    'leftrightharpoons': '\u21CB',
-    'leftrightsquigarrow': '\u21AD',
-    'leg': '\u22DA',
-    'leq': '\u2264',
-    'leqq': '\u2266',
-    'leqslant': '\u2A7D',
-    'les': '\u2A7D',
-    'lescc': '\u2AA8',
-    'lesdot': '\u2A7F',
-    'lesdoto': '\u2A81',
-    'lesdotor': '\u2A83',
-    'lesg': '\u22DA\uFE00',
-    'lesges': '\u2A93',
-    'lessapprox': '\u2A85',
-    'lesseqgtr': '\u22DA',
-    'lesseqqgtr': '\u2A8B',
-    'lessgtr': '\u2276',
-    'lesssim': '\u2272',
-    'lfisht': '\u297C',
-    'lfloor': '\u230A',
-    'lg': '\u2276',
-    'lgE': '\u2A91',
-    'lhard': '\u21BD',
-    'lharu': '\u21BC',
-    'lharul': '\u296A',
-    'lhblk': '\u2584',
-    'ljcy': '\u0459',
-    'll': '\u226A',
-    'llarr': '\u21C7',
-    'llcorner': '\u231E',
-    'llhard': '\u296B',
-    'lltri': '\u25FA',
-    'lmidot': '\u0140',
-    'lmoustache': '\u23B0',
-    'lnapprox': '\u2A89',
-    'lneq': '\u2A87',
-    'lneqq': '\u2268',
-    'loang': '\u3018',
-    'loarr': '\u21FD',
-    'lobrk': '\u301A',
-    'longleftarrow': '\u27F5',
-    'longleftrightarrow': '\u27F7',
-    'longrightarrow': '\u27F6',
-    'looparrowleft': '\u21AB',
-    'lopar': '\u2985',
-    'loplus': '\u2A2D',
-    'lotimes': '\u2A34',
-    'lozenge': '\u25CA',
-    'lozf': '\u29EB',
-    'lpar': '\u0028',
-    'lparlt': '\u2993',
-    'lrarr': '\u21C6',
-    'lrcorner': '\u231F',
-    'lrhar': '\u21CB',
-    'lrhard': '\u296D',
-    'lrtri': '\u22BF',
-    'lsh': '\u21B0',
-    'lsim': '\u2272',
-    'lsime': '\u2A8D',
-    'lsimg': '\u2A8F',
-    'lsqb': '\u005B',
-    'lsquo': '\u2018',
-    'lsquor': '\u201A',
-    'lstrok': '\u0142',
-    'ltcc': '\u2AA6',
-    'ltcir': '\u2A79',
-    'ltdot': '\u22D6',
-    'lthree': '\u22CB',
-    'ltlarr': '\u2976',
-    'ltquest': '\u2A7B',
-    'ltrPar': '\u2996',
-    'ltrie': '\u22B4',
-    'ltrif': '\u25C2',
-    'lurdshar': '\u294A',
-    'luruhar': '\u2966',
-    'lvertneqq': '\u2268\uFE00',
-    'lvnE': '\u2268\uFE00'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/l.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/m.js

@@ -1,61 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/m.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Map': '\u2905',
-    'Mcy': '\u041C',
-    'MediumSpace': '\u205F',
-    'Mellintrf': '\u2133',
-    'mDDot': '\u223A',
-    'macr': '\u00AF',
-    'male': '\u2642',
-    'maltese': '\u2720',
-    'map': '\u21A6',
-    'mapsto': '\u21A6',
-    'mapstodown': '\u21A7',
-    'mapstoleft': '\u21A4',
-    'mapstoup': '\u21A5',
-    'marker': '\u25AE',
-    'mcomma': '\u2A29',
-    'mcy': '\u043C',
-    'mdash': '\u2014',
-    'measuredangle': '\u2221',
-    'micro': '\u00B5',
-    'mid': '\u2223',
-    'midast': '\u002A',
-    'midcir': '\u2AF0',
-    'middot': '\u00B7',
-    'minus': '\u2212',
-    'minusb': '\u229F',
-    'minusd': '\u2238',
-    'minusdu': '\u2A2A',
-    'mlcp': '\u2ADB',
-    'mldr': '\u2026',
-    'mnplus': '\u2213',
-    'models': '\u22A7',
-    'mp': '\u2213',
-    'mstpos': '\u223E',
-    'mumap': '\u22B8'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/m.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/n.js

@@ -1,219 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/n.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'NJcy': '\u040A',
-    'Nacute': '\u0143',
-    'Ncaron': '\u0147',
-    'Ncedil': '\u0145',
-    'Ncy': '\u041D',
-    'NegativeMediumSpace': '\u200B',
-    'NegativeThickSpace': '\u200B',
-    'NegativeThinSpace': '\u200B',
-    'NegativeVeryThinSpace': '\u200B',
-    'NewLine': '\u000A',
-    'NoBreak': '\u2060',
-    'NonBreakingSpace': '\u00A0',
-    'Not': '\u2AEC',
-    'NotCongruent': '\u2262',
-    'NotCupCap': '\u226D',
-    'NotEqualTilde': '\u2242\u0338',
-    'NotGreaterFullEqual': '\u2266\u0338',
-    'NotGreaterGreater': '\u226B\u0338',
-    'NotGreaterLess': '\u2279',
-    'NotGreaterSlantEqual': '\u2A7E\u0338',
-    'NotGreaterTilde': '\u2275',
-    'NotHumpDownHump': '\u224E\u0338',
-    'NotHumpEqual': '\u224F\u0338',
-    'NotLeftTriangleBar': '\u29CF\u0338',
-    'NotLessGreater': '\u2278',
-    'NotLessLess': '\u226A\u0338',
-    'NotLessSlantEqual': '\u2A7D\u0338',
-    'NotLessTilde': '\u2274',
-    'NotNestedGreaterGreater': '\u2AA2\u0338',
-    'NotNestedLessLess': '\u2AA1\u0338',
-    'NotPrecedesEqual': '\u2AAF\u0338',
-    'NotReverseElement': '\u220C',
-    'NotRightTriangleBar': '\u29D0\u0338',
-    'NotSquareSubset': '\u228F\u0338',
-    'NotSquareSubsetEqual': '\u22E2',
-    'NotSquareSuperset': '\u2290\u0338',
-    'NotSquareSupersetEqual': '\u22E3',
-    'NotSubset': '\u2282\u20D2',
-    'NotSucceedsEqual': '\u2AB0\u0338',
-    'NotSucceedsTilde': '\u227F\u0338',
-    'NotSuperset': '\u2283\u20D2',
-    'NotTildeEqual': '\u2244',
-    'NotTildeFullEqual': '\u2247',
-    'NotTildeTilde': '\u2249',
-    'Ntilde': '\u00D1',
-    'nGg': '\u22D9\u0338',
-    'nGt': '\u226B\u20D2',
-    'nGtv': '\u226B\u0338',
-    'nLeftarrow': '\u21CD',
-    'nLeftrightarrow': '\u21CE',
-    'nLl': '\u22D8\u0338',
-    'nLt': '\u226A\u20D2',
-    'nLtv': '\u226A\u0338',
-    'nRightarrow': '\u21CF',
-    'nabla': '\u2207',
-    'nacute': '\u0144',
-    'nang': '\u2220\u20D2',
-    'nap': '\u2249',
-    'napE': '\u2A70\u0338',
-    'napid': '\u224B\u0338',
-    'napos': '\u0149',
-    'napprox': '\u2249',
-    'natural': '\u266E',
-    'naturals': '\u2115',
-    'nbsp': '\u00A0',
-    'nbump': '\u224E\u0338',
-    'nbumpe': '\u224F\u0338',
-    'ncap': '\u2A43',
-    'ncaron': '\u0148',
-    'ncedil': '\u0146',
-    'ncong': '\u2247',
-    'ncongdot': '\u2A6D\u0338',
-    'ncup': '\u2A42',
-    'ncy': '\u043D',
-    'ndash': '\u2013',
-    'ne': '\u2260',
-    'neArr': '\u21D7',
-    'nearhk': '\u2924',
-    'nearrow': '\u2197',
-    'nedot': '\u2250\u0338',
-    'nequiv': '\u2262',
-    'nesear': '\u2928',
-    'nesim': '\u2242\u0338',
-    'nexist': '\u2204',
-    'nexists': '\u2204',
-    'ngE': '\u2267\u0338',
-    'nge': '\u2271',
-    'ngeq': '\u2271',
-    'ngeqq': '\u2267\u0338',
-    'ngeqslant': '\u2A7E\u0338',
-    'nges': '\u2A7E\u0338',
-    'ngsim': '\u2275',
-    'ngt': '\u226F',
-    'ngtr': '\u226F',
-    'nhpar': '\u2AF2',
-    'ni': '\u220B',
-    'nis': '\u22FC',
-    'nisd': '\u22FA',
-    'niv': '\u220B',
-    'njcy': '\u045A',
-    'nlE': '\u2266\u0338',
-    'nldr': '\u2025',
-    'nle': '\u2270',
-    'nleftarrow': '\u219A',
-    'nleftrightarrow': '\u21AE',
-    'nleq': '\u2270',
-    'nleqq': '\u2266\u0338',
-    'nleqslant': '\u2A7D\u0338',
-    'nles': '\u2A7D\u0338',
-    'nless': '\u226E',
-    'nlsim': '\u2274',
-    'nlt': '\u226E',
-    'nltri': '\u22EA',
-    'nltrie': '\u22EC',
-    'nmid': '\u2224',
-    'notin': '\u2209',
-    'notinE': '\u22F9\u0338',
-    'notindot': '\u22F5\u0338',
-    'notinva': '\u2209',
-    'notinvb': '\u22F7',
-    'notinvc': '\u22F6',
-    'notni': '\u220C',
-    'notniva': '\u220C',
-    'notnivb': '\u22FE',
-    'notnivc': '\u22FD',
-    'npar': '\u2226',
-    'nparallel': '\u2226',
-    'nparsl': '\u2AFD\u20E5',
-    'npart': '\u2202\u0338',
-    'npolint': '\u2A14',
-    'npr': '\u2280',
-    'nprcue': '\u22E0',
-    'npre': '\u2AAF\u0338',
-    'nprec': '\u2280',
-    'npreceq': '\u2AAF\u0338',
-    'nrarrc': '\u2933\u0338',
-    'nrarrw': '\u219D\u0338',
-    'nrightarrow': '\u219B',
-    'nrtri': '\u22EB',
-    'nrtrie': '\u22ED',
-    'nsc': '\u2281',
-    'nsccue': '\u22E1',
-    'nsce': '\u2AB0\u0338',
-    'nshortmid': '\u2224',
-    'nshortparallel': '\u2226',
-    'nsim': '\u2241',
-    'nsime': '\u2244',
-    'nsimeq': '\u2244',
-    'nsmid': '\u2224',
-    'nspar': '\u2226',
-    'nsqsube': '\u22E2',
-    'nsqsupe': '\u22E3',
-    'nsub': '\u2284',
-    'nsubE': '\u2AC5\u0338',
-    'nsube': '\u2288',
-    'nsubset': '\u2282\u20D2',
-    'nsubseteq': '\u2288',
-    'nsubseteqq': '\u2AC5\u0338',
-    'nsucc': '\u2281',
-    'nsucceq': '\u2AB0\u0338',
-    'nsup': '\u2285',
-    'nsupE': '\u2AC6\u0338',
-    'nsupe': '\u2289',
-    'nsupset': '\u2283\u20D2',
-    'nsupseteq': '\u2289',
-    'nsupseteqq': '\u2AC6\u0338',
-    'ntgl': '\u2279',
-    'ntilde': '\u00F1',
-    'ntlg': '\u2278',
-    'ntriangleleft': '\u22EA',
-    'ntrianglelefteq': '\u22EC',
-    'ntriangleright': '\u22EB',
-    'ntrianglerighteq': '\u22ED',
-    'num': '\u0023',
-    'numero': '\u2116',
-    'numsp': '\u2007',
-    'nvHarr': '\u2904',
-    'nvap': '\u224D\u20D2',
-    'nvge': '\u2265\u20D2',
-    'nvgt': '\u003E\u20D2',
-    'nvinfin': '\u29DE',
-    'nvlArr': '\u2902',
-    'nvle': '\u2264\u20D2',
-    'nvlt': '\u003C\u20D2',
-    'nvltrie': '\u22B4\u20D2',
-    'nvrArr': '\u2903',
-    'nvrtrie': '\u22B5\u20D2',
-    'nvsim': '\u223C\u20D2',
-    'nwArr': '\u21D6',
-    'nwarhk': '\u2923',
-    'nwarrow': '\u2196',
-    'nwnear': '\u2927'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/n.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/o.js

@@ -1,88 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/o.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'OElig': '\u0152',
-    'Oacute': '\u00D3',
-    'Ocirc': '\u00D4',
-    'Ocy': '\u041E',
-    'Odblac': '\u0150',
-    'Ograve': '\u00D2',
-    'Omacr': '\u014C',
-    'OpenCurlyDoubleQuote': '\u201C',
-    'OpenCurlyQuote': '\u2018',
-    'Or': '\u2A54',
-    'Oslash': '\u00D8',
-    'Otilde': '\u00D5',
-    'Otimes': '\u2A37',
-    'Ouml': '\u00D6',
-    'OverBracket': '\u23B4',
-    'OverParenthesis': '\uFE35',
-    'oS': '\u24C8',
-    'oacute': '\u00F3',
-    'oast': '\u229B',
-    'ocir': '\u229A',
-    'ocirc': '\u00F4',
-    'ocy': '\u043E',
-    'odash': '\u229D',
-    'odblac': '\u0151',
-    'odiv': '\u2A38',
-    'odot': '\u2299',
-    'odsold': '\u29BC',
-    'oelig': '\u0153',
-    'ofcir': '\u29BF',
-    'ogon': '\u02DB',
-    'ograve': '\u00F2',
-    'ogt': '\u29C1',
-    'ohbar': '\u29B5',
-    'ohm': '\u2126',
-    'oint': '\u222E',
-    'olarr': '\u21BA',
-    'olcir': '\u29BE',
-    'olcross': '\u29BB',
-    'olt': '\u29C0',
-    'omacr': '\u014D',
-    'omid': '\u29B6',
-    'ominus': '\u2296',
-    'opar': '\u29B7',
-    'operp': '\u29B9',
-    'oplus': '\u2295',
-    'orarr': '\u21BB',
-    'ord': '\u2A5D',
-    'order': '\u2134',
-    'orderof': '\u2134',
-    'ordf': '\u00AA',
-    'ordm': '\u00BA',
-    'origof': '\u22B6',
-    'oror': '\u2A56',
-    'orslope': '\u2A57',
-    'orv': '\u2A5B',
-    'oslash': '\u00F8',
-    'otilde': '\u00F5',
-    'otimes': '\u2297',
-    'otimesas': '\u2A36',
-    'ouml': '\u00F6',
-    'ovbar': '\u233D'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/o.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/opf.js

@@ -1,79 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/opf.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Aopf': '\uD835\uDD38',
-    'Bopf': '\uD835\uDD39',
-    'Copf': '\u2102',
-    'Dopf': '\uD835\uDD3B',
-    'Eopf': '\uD835\uDD3C',
-    'Fopf': '\uD835\uDD3D',
-    'Gopf': '\uD835\uDD3E',
-    'Hopf': '\u210D',
-    'Iopf': '\uD835\uDD40',
-    'Jopf': '\uD835\uDD41',
-    'Kopf': '\uD835\uDD42',
-    'Lopf': '\uD835\uDD43',
-    'Mopf': '\uD835\uDD44',
-    'Nopf': '\u2115',
-    'Oopf': '\uD835\uDD46',
-    'Popf': '\u2119',
-    'Qopf': '\u211A',
-    'Ropf': '\u211D',
-    'Sopf': '\uD835\uDD4A',
-    'Topf': '\uD835\uDD4B',
-    'Uopf': '\uD835\uDD4C',
-    'Vopf': '\uD835\uDD4D',
-    'Wopf': '\uD835\uDD4E',
-    'Xopf': '\uD835\uDD4F',
-    'Yopf': '\uD835\uDD50',
-    'Zopf': '\u2124',
-    'aopf': '\uD835\uDD52',
-    'bopf': '\uD835\uDD53',
-    'copf': '\uD835\uDD54',
-    'dopf': '\uD835\uDD55',
-    'eopf': '\uD835\uDD56',
-    'fopf': '\uD835\uDD57',
-    'gopf': '\uD835\uDD58',
-    'hopf': '\uD835\uDD59',
-    'iopf': '\uD835\uDD5A',
-    'jopf': '\uD835\uDD5B',
-    'kopf': '\uD835\uDD5C',
-    'lopf': '\uD835\uDD5D',
-    'mopf': '\uD835\uDD5E',
-    'nopf': '\uD835\uDD5F',
-    'oopf': '\uD835\uDD60',
-    'popf': '\uD835\uDD61',
-    'qopf': '\uD835\uDD62',
-    'ropf': '\uD835\uDD63',
-    'sopf': '\uD835\uDD64',
-    'topf': '\uD835\uDD65',
-    'uopf': '\uD835\uDD66',
-    'vopf': '\uD835\uDD67',
-    'wopf': '\uD835\uDD68',
-    'xopf': '\uD835\uDD69',
-    'yopf': '\uD835\uDD6A',
-    'zopf': '\uD835\uDD6B'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/opf.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/p.js

@@ -1,84 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/p.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Pcy': '\u041F',
-    'Poincareplane': '\u210C',
-    'Pr': '\u2ABB',
-    'Prime': '\u2033',
-    'Proportion': '\u2237',
-    'par': '\u2225',
-    'para': '\u00B6',
-    'parallel': '\u2225',
-    'parsim': '\u2AF3',
-    'parsl': '\u2AFD',
-    'part': '\u2202',
-    'pcy': '\u043F',
-    'percnt': '\u0025',
-    'permil': '\u2030',
-    'perp': '\u22A5',
-    'pertenk': '\u2031',
-    'phmmat': '\u2133',
-    'phone': '\u260E',
-    'pitchfork': '\u22D4',
-    'planck': '\u210F',
-    'planckh': '\u210E',
-    'plankv': '\u210F',
-    'plus': '\u002B',
-    'plusacir': '\u2A23',
-    'plusb': '\u229E',
-    'pluscir': '\u2A22',
-    'plusdo': '\u2214',
-    'plusdu': '\u2A25',
-    'pluse': '\u2A72',
-    'plusmn': '\u00B1',
-    'plussim': '\u2A26',
-    'plustwo': '\u2A27',
-    'pm': '\u00B1',
-    'pointint': '\u2A15',
-    'pound': '\u00A3',
-    'pr': '\u227A',
-    'prE': '\u2AB3',
-    'prcue': '\u227C',
-    'pre': '\u2AAF',
-    'prec': '\u227A',
-    'precapprox': '\u2AB7',
-    'preccurlyeq': '\u227C',
-    'preceq': '\u2AAF',
-    'precsim': '\u227E',
-    'primes': '\u2119',
-    'prnE': '\u2AB5',
-    'prnap': '\u2AB9',
-    'prnsim': '\u22E8',
-    'prod': '\u220F',
-    'profalar': '\u232E',
-    'profline': '\u2312',
-    'profsurf': '\u2313',
-    'prop': '\u221D',
-    'propto': '\u221D',
-    'prsim': '\u227E',
-    'prurel': '\u22B0',
-    'puncsp': '\u2008'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/p.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/q.js

@@ -1,34 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/q.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'qint': '\u2A0C',
-    'qprime': '\u2057',
-    'quaternions': '\u210D',
-    'quatint': '\u2A16',
-    'quest': '\u003F',
-    'questeq': '\u225F',
-    'quot': '\u0022'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/q.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/r.js

@@ -1,134 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/r.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'RBarr': '\u2910',
-    'Racute': '\u0154',
-    'Rang': '\u300B',
-    'Rarrtl': '\u2916',
-    'Rcaron': '\u0158',
-    'Rcedil': '\u0156',
-    'Rcy': '\u0420',
-    'ReverseElement': '\u220B',
-    'ReverseUpEquilibrium': '\u296F',
-    'RightArrowBar': '\u21E5',
-    'RightDoubleBracket': '\u301B',
-    'RightDownTeeVector': '\u295D',
-    'RightDownVectorBar': '\u2955',
-    'RightTeeVector': '\u295B',
-    'RightTriangleBar': '\u29D0',
-    'RightUpDownVector': '\u294F',
-    'RightUpTeeVector': '\u295C',
-    'RightUpVectorBar': '\u2954',
-    'RightVectorBar': '\u2953',
-    'RoundImplies': '\u2970',
-    'RuleDelayed': '\u29F4',
-    'rAarr': '\u21DB',
-    'rArr': '\u21D2',
-    'rAtail': '\u291C',
-    'rBarr': '\u290F',
-    'rHar': '\u2964',
-    'race': '\u29DA',
-    'racute': '\u0155',
-    'radic': '\u221A',
-    'raemptyv': '\u29B3',
-    'rang': '\u232A',
-    'rangd': '\u2992',
-    'range': '\u29A5',
-    'rangle': '\u232A',
-    'raquo': '\u00BB',
-    'rarr': '\u2192',
-    'rarrap': '\u2975',
-    'rarrb': '\u21E5',
-    'rarrbfs': '\u2920',
-    'rarrc': '\u2933',
-    'rarrfs': '\u291E',
-    'rarrhk': '\u21AA',
-    'rarrlp': '\u21AC',
-    'rarrpl': '\u2945',
-    'rarrsim': '\u2974',
-    'rarrw': '\u219D',
-    'ratail': '\u291A',
-    'ratio': '\u2236',
-    'rationals': '\u211A',
-    'rbarr': '\u290D',
-    'rbbrk': '\u3015',
-    'rbrke': '\u298C',
-    'rbrksld': '\u298E',
-    'rbrkslu': '\u2990',
-    'rcaron': '\u0159',
-    'rcedil': '\u0157',
-    'rceil': '\u2309',
-    'rcub': '\u007D',
-    'rcy': '\u0440',
-    'rdca': '\u2937',
-    'rdldhar': '\u2969',
-    'rdquo': '\u201D',
-    'rdquor': '\u201D',
-    'rdsh': '\u21B3',
-    'real': '\u211C',
-    'realine': '\u211B',
-    'realpart': '\u211C',
-    'reals': '\u211D',
-    'rect': '\u25AD',
-    'reg': '\u00AE',
-    'rfisht': '\u297D',
-    'rfloor': '\u230B',
-    'rhard': '\u21C1',
-    'rharu': '\u21C0',
-    'rharul': '\u296C',
-    'rightarrow': '\u2192',
-    'rightarrowtail': '\u21A3',
-    'rightharpoondown': '\u21C1',
-    'rightharpoonup': '\u21C0',
-    'rightleftarrows': '\u21C4',
-    'rightleftharpoons': '\u21CC',
-    'rightsquigarrow': '\u219D',
-    'risingdotseq': '\u2253',
-    'rlarr': '\u21C4',
-    'rlhar': '\u21CC',
-    'rmoustache': '\u23B1',
-    'rnmid': '\u2AEE',
-    'roang': '\u3019',
-    'roarr': '\u21FE',
-    'robrk': '\u301B',
-    'ropar': '\u2986',
-    'roplus': '\u2A2E',
-    'rotimes': '\u2A35',
-    'rpar': '\u0029',
-    'rpargt': '\u2994',
-    'rppolint': '\u2A12',
-    'rrarr': '\u21C9',
-    'rsh': '\u21B1',
-    'rsqb': '\u005D',
-    'rsquo': '\u2019',
-    'rsquor': '\u2019',
-    'rthree': '\u22CC',
-    'rtrie': '\u22B5',
-    'rtrif': '\u25B8',
-    'rtriltri': '\u29CE',
-    'ruluhar': '\u2968',
-    'rx': '\u211E'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/r.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/s.js

@@ -1,168 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/s.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'SHCHcy': '\u0429',
-    'SHcy': '\u0428',
-    'SOFTcy': '\u042C',
-    'Sacute': '\u015A',
-    'Sc': '\u2ABC',
-    'Scaron': '\u0160',
-    'Scedil': '\u015E',
-    'Scirc': '\u015C',
-    'Scy': '\u0421',
-    'ShortDownArrow': '\u2193',
-    'ShortLeftArrow': '\u2190',
-    'ShortRightArrow': '\u2192',
-    'ShortUpArrow': '\u2191',
-    'Sub': '\u22D0',
-    'Sup': '\u22D1',
-    'sacute': '\u015B',
-    'sc': '\u227B',
-    'scE': '\u2AB4',
-    'scaron': '\u0161',
-    'sccue': '\u227D',
-    'sce': '\u2AB0',
-    'scedil': '\u015F',
-    'scirc': '\u015D',
-    'scpolint': '\u2A13',
-    'scsim': '\u227F',
-    'scy': '\u0441',
-    'sdotb': '\u22A1',
-    'sdote': '\u2A66',
-    'seArr': '\u21D8',
-    'searhk': '\u2925',
-    'searrow': '\u2198',
-    'semi': '\u003B',
-    'seswar': '\u2929',
-    'setminus': '\u2216',
-    'setmn': '\u2216',
-    'sext': '\u2736',
-    'sfrown': '\u2322',
-    'shchcy': '\u0449',
-    'shcy': '\u0448',
-    'shortmid': '\u2223',
-    'shortparallel': '\u2225',
-    'shy': '\u00AD',
-    'sim': '\u223C',
-    'simdot': '\u2A6A',
-    'sime': '\u2243',
-    'simeq': '\u2243',
-    'simg': '\u2A9E',
-    'simgE': '\u2AA0',
-    'siml': '\u2A9D',
-    'simlE': '\u2A9F',
-    'simplus': '\u2A24',
-    'simrarr': '\u2972',
-    'slarr': '\u2190',
-    'smallsetminus': '\u2216',
-    'smashp': '\u2A33',
-    'smeparsl': '\u29E4',
-    'smid': '\u2223',
-    'smt': '\u2AAA',
-    'smte': '\u2AAC',
-    'smtes': '\u2AAC\uFE00',
-    'softcy': '\u044C',
-    'sol': '\u002F',
-    'solb': '\u29C4',
-    'solbar': '\u233F',
-    'spadesuit': '\u2660',
-    'spar': '\u2225',
-    'sqcap': '\u2293',
-    'sqcaps': '\u2293\uFE00',
-    'sqcup': '\u2294',
-    'sqcups': '\u2294\uFE00',
-    'sqsub': '\u228F',
-    'sqsube': '\u2291',
-    'sqsubset': '\u228F',
-    'sqsubseteq': '\u2291',
-    'sqsup': '\u2290',
-    'sqsupe': '\u2292',
-    'sqsupset': '\u2290',
-    'sqsupseteq': '\u2292',
-    'squ': '\u25A1',
-    'square': '\u25A1',
-    'squarf': '\u25AA',
-    'squf': '\u25AA',
-    'srarr': '\u2192',
-    'ssetmn': '\u2216',
-    'ssmile': '\u2323',
-    'sstarf': '\u22C6',
-    'star': '\u2606',
-    'starf': '\u2605',
-    'straightepsilon': '\u03F5',
-    'straightphi': '\u03D5',
-    'strns': '\u00AF',
-    'subdot': '\u2ABD',
-    'sube': '\u2286',
-    'subedot': '\u2AC3',
-    'submult': '\u2AC1',
-    'subplus': '\u2ABF',
-    'subrarr': '\u2979',
-    'subset': '\u2282',
-    'subseteq': '\u2286',
-    'subseteqq': '\u2AC5',
-    'subsetneq': '\u228A',
-    'subsetneqq': '\u2ACB',
-    'subsim': '\u2AC7',
-    'subsub': '\u2AD5',
-    'subsup': '\u2AD3',
-    'succ': '\u227B',
-    'succapprox': '\u2AB8',
-    'succcurlyeq': '\u227D',
-    'succeq': '\u2AB0',
-    'succnapprox': '\u2ABA',
-    'succneqq': '\u2AB6',
-    'succnsim': '\u22E9',
-    'succsim': '\u227F',
-    'sum': '\u2211',
-    'sung': '\u266A',
-    'sup': '\u2283',
-    'sup1': '\u00B9',
-    'sup2': '\u00B2',
-    'sup3': '\u00B3',
-    'supdot': '\u2ABE',
-    'supdsub': '\u2AD8',
-    'supe': '\u2287',
-    'supedot': '\u2AC4',
-    'suphsol': '\u2283\u002F',
-    'suphsub': '\u2AD7',
-    'suplarr': '\u297B',
-    'supmult': '\u2AC2',
-    'supplus': '\u2AC0',
-    'supset': '\u2283',
-    'supseteq': '\u2287',
-    'supseteqq': '\u2AC6',
-    'supsetneq': '\u228B',
-    'supsetneqq': '\u2ACC',
-    'supsim': '\u2AC8',
-    'supsub': '\u2AD4',
-    'supsup': '\u2AD6',
-    'swArr': '\u21D9',
-    'swarhk': '\u2926',
-    'swarrow': '\u2199',
-    'swnwar': '\u292A',
-    'szlig': '\u00DF'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/s.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/scr.js

@@ -1,79 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/scr.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Ascr': '\uD835\uDC9C',
-    'Bscr': '\u212C',
-    'Cscr': '\uD835\uDC9E',
-    'Dscr': '\uD835\uDC9F',
-    'Escr': '\u2130',
-    'Fscr': '\u2131',
-    'Gscr': '\uD835\uDCA2',
-    'Hscr': '\u210B',
-    'Iscr': '\u2110',
-    'Jscr': '\uD835\uDCA5',
-    'Kscr': '\uD835\uDCA6',
-    'Lscr': '\u2112',
-    'Mscr': '\u2133',
-    'Nscr': '\uD835\uDCA9',
-    'Oscr': '\uD835\uDCAA',
-    'Pscr': '\uD835\uDCAB',
-    'Qscr': '\uD835\uDCAC',
-    'Rscr': '\u211B',
-    'Sscr': '\uD835\uDCAE',
-    'Tscr': '\uD835\uDCAF',
-    'Uscr': '\uD835\uDCB0',
-    'Vscr': '\uD835\uDCB1',
-    'Wscr': '\uD835\uDCB2',
-    'Xscr': '\uD835\uDCB3',
-    'Yscr': '\uD835\uDCB4',
-    'Zscr': '\uD835\uDCB5',
-    'ascr': '\uD835\uDCB6',
-    'bscr': '\uD835\uDCB7',
-    'cscr': '\uD835\uDCB8',
-    'dscr': '\uD835\uDCB9',
-    'escr': '\u212F',
-    'fscr': '\uD835\uDCBB',
-    'gscr': '\u210A',
-    'hscr': '\uD835\uDCBD',
-    'iscr': '\uD835\uDCBE',
-    'jscr': '\uD835\uDCBF',
-    'kscr': '\uD835\uDCC0',
-    'lscr': '\uD835\uDCC1',
-    'mscr': '\uD835\uDCC2',
-    'nscr': '\uD835\uDCC3',
-    'oscr': '\u2134',
-    'pscr': '\uD835\uDCC5',
-    'qscr': '\uD835\uDCC6',
-    'rscr': '\uD835\uDCC7',
-    'sscr': '\uD835\uDCC8',
-    'tscr': '\uD835\uDCC9',
-    'uscr': '\uD835\uDCCA',
-    'vscr': '\uD835\uDCCB',
-    'wscr': '\uD835\uDCCC',
-    'xscr': '\uD835\uDCCD',
-    'yscr': '\uD835\uDCCE',
-    'zscr': '\uD835\uDCCF'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/scr.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/t.js

@@ -1,82 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/t.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'THORN': '\u00DE',
-    'TSHcy': '\u040B',
-    'TScy': '\u0426',
-    'Tab': '\u0009',
-    'Tcaron': '\u0164',
-    'Tcedil': '\u0162',
-    'Tcy': '\u0422',
-    'ThinSpace': '\u2009',
-    'TripleDot': '\u20DB',
-    'Tstrok': '\u0166',
-    'target': '\u2316',
-    'tbrk': '\u23B4',
-    'tcaron': '\u0165',
-    'tcedil': '\u0163',
-    'tcy': '\u0442',
-    'tdot': '\u20DB',
-    'telrec': '\u2315',
-    'there4': '\u2234',
-    'therefore': '\u2234',
-    'thickapprox': '\u2248',
-    'thicksim': '\u223C',
-    'thinsp': '\u2009',
-    'thkap': '\u2248',
-    'thksim': '\u223C',
-    'thorn': '\u00FE',
-    'timesb': '\u22A0',
-    'timesbar': '\u2A31',
-    'timesd': '\u2A30',
-    'tint': '\u222D',
-    'toea': '\u2928',
-    'top': '\u22A4',
-    'topbot': '\u2336',
-    'topcir': '\u2AF1',
-    'topfork': '\u2ADA',
-    'tosa': '\u2929',
-    'tprime': '\u2034',
-    'trade': '\u2122',
-    'triangledown': '\u25BF',
-    'triangleleft': '\u25C3',
-    'trianglelefteq': '\u22B4',
-    'triangleright': '\u25B9',
-    'trianglerighteq': '\u22B5',
-    'tridot': '\u25EC',
-    'trie': '\u225C',
-    'triminus': '\u2A3A',
-    'triplus': '\u2A39',
-    'trisb': '\u29CD',
-    'tritime': '\u2A3B',
-    'trpezium': '\uFFFD',
-    'tscy': '\u0446',
-    'tshcy': '\u045B',
-    'tstrok': '\u0167',
-    'twixt': '\u226C',
-    'twoheadleftarrow': '\u219E',
-    'twoheadrightarrow': '\u21A0'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/t.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/u.js

@@ -1,91 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/u.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Uacute': '\u00DA',
-    'Uarr': '\u219F',
-    'Uarrocir': '\u2949',
-    'Ubrcy': '\u040E',
-    'Ubreve': '\u016C',
-    'Ucirc': '\u00DB',
-    'Ucy': '\u0423',
-    'Udblac': '\u0170',
-    'Ugrave': '\u00D9',
-    'Umacr': '\u016A',
-    'UnderBracket': '\u23B5',
-    'UnderParenthesis': '\uFE36',
-    'Uogon': '\u0172',
-    'UpArrowBar': '\u2912',
-    'UpArrowDownArrow': '\u21C5',
-    'UpEquilibrium': '\u296E',
-    'UpTeeArrow': '\u21A5',
-    'UpperLeftArrow': '\u2196',
-    'UpperRightArrow': '\u2197',
-    'Upsi': '\u03D2',
-    'Uring': '\u016E',
-    'Utilde': '\u0168',
-    'Uuml': '\u00DC',
-    'uArr': '\u21D1',
-    'uHar': '\u2963',
-    'uacute': '\u00FA',
-    'uarr': '\u2191',
-    'ubrcy': '\u045E',
-    'ubreve': '\u016D',
-    'ucirc': '\u00FB',
-    'ucy': '\u0443',
-    'udarr': '\u21C5',
-    'udblac': '\u0171',
-    'udhar': '\u296E',
-    'ufisht': '\u297E',
-    'ugrave': '\u00F9',
-    'uharl': '\u21BF',
-    'uharr': '\u21BE',
-    'uhblk': '\u2580',
-    'ulcorn': '\u231C',
-    'ulcorner': '\u231C',
-    'ulcrop': '\u230F',
-    'ultri': '\u25F8',
-    'umacr': '\u016B',
-    'uml': '\u00A8',
-    'uogon': '\u0173',
-    'uparrow': '\u2191',
-    'updownarrow': '\u2195',
-    'upharpoonleft': '\u21BF',
-    'upharpoonright': '\u21BE',
-    'uplus': '\u228E',
-    'upsilon': '\u03C5',
-    'urcorn': '\u231D',
-    'urcorner': '\u231D',
-    'urcrop': '\u230E',
-    'uring': '\u016F',
-    'urtri': '\u25F9',
-    'utdot': '\u22F0',
-    'utilde': '\u0169',
-    'utri': '\u25B5',
-    'utrif': '\u25B4',
-    'uuarr': '\u21C8',
-    'uuml': '\u00FC',
-    'uwangle': '\u29A7'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/u.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/v.js

@@ -1,73 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/v.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'VDash': '\u22AB',
-    'Vbar': '\u2AEB',
-    'Vcy': '\u0412',
-    'Vdashl': '\u2AE6',
-    'Verbar': '\u2016',
-    'Vert': '\u2016',
-    'VerticalLine': '\u007C',
-    'VerticalSeparator': '\u2758',
-    'VeryThinSpace': '\u200A',
-    'vArr': '\u21D5',
-    'vBar': '\u2AE8',
-    'vBarv': '\u2AE9',
-    'vDash': '\u22A8',
-    'vangrt': '\u299C',
-    'varepsilon': '\u03B5',
-    'varkappa': '\u03F0',
-    'varnothing': '\u2205',
-    'varphi': '\u03C6',
-    'varpi': '\u03D6',
-    'varpropto': '\u221D',
-    'varr': '\u2195',
-    'varrho': '\u03F1',
-    'varsigma': '\u03C2',
-    'varsubsetneq': '\u228A\uFE00',
-    'varsubsetneqq': '\u2ACB\uFE00',
-    'varsupsetneq': '\u228B\uFE00',
-    'varsupsetneqq': '\u2ACC\uFE00',
-    'vartheta': '\u03D1',
-    'vartriangleleft': '\u22B2',
-    'vartriangleright': '\u22B3',
-    'vcy': '\u0432',
-    'vdash': '\u22A2',
-    'vee': '\u2228',
-    'veeeq': '\u225A',
-    'verbar': '\u007C',
-    'vert': '\u007C',
-    'vltri': '\u22B2',
-    'vnsub': '\u2282\u20D2',
-    'vnsup': '\u2283\u20D2',
-    'vprop': '\u221D',
-    'vrtri': '\u22B3',
-    'vsubnE': '\u2ACB\uFE00',
-    'vsubne': '\u228A\uFE00',
-    'vsupnE': '\u2ACC\uFE00',
-    'vsupne': '\u228B\uFE00',
-    'vzigzag': '\u299A'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/v.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/w.js

@@ -1,35 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/w.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'Wcirc': '\u0174',
-    'wcirc': '\u0175',
-    'wedbar': '\u2A5F',
-    'wedge': '\u2227',
-    'wedgeq': '\u2259',
-    'wp': '\u2118',
-    'wr': '\u2240',
-    'wreath': '\u2240'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/w.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/x.js

@@ -1,47 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/x.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'xcap': '\u22C2',
-    'xcirc': '\u25EF',
-    'xcup': '\u22C3',
-    'xdtri': '\u25BD',
-    'xhArr': '\u27FA',
-    'xharr': '\u27F7',
-    'xlArr': '\u27F8',
-    'xlarr': '\u27F5',
-    'xmap': '\u27FC',
-    'xnis': '\u22FB',
-    'xodot': '\u2A00',
-    'xoplus': '\u2A01',
-    'xotime': '\u2A02',
-    'xrArr': '\u27F9',
-    'xrarr': '\u27F6',
-    'xsqcup': '\u2A06',
-    'xuplus': '\u2A04',
-    'xutri': '\u25B3',
-    'xvee': '\u22C1',
-    'xwedge': '\u22C0'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/x.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/y.js

@@ -1,41 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/y.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'YAcy': '\u042F',
-    'YIcy': '\u0407',
-    'YUcy': '\u042E',
-    'Yacute': '\u00DD',
-    'Ycirc': '\u0176',
-    'Ycy': '\u042B',
-    'Yuml': '\u0178',
-    'yacute': '\u00FD',
-    'yacy': '\u044F',
-    'ycirc': '\u0177',
-    'ycy': '\u044B',
-    'yicy': '\u0457',
-    'yucy': '\u044E',
-    'yuml': '\u00FF'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/y.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/entities/z.js

@@ -1,39 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/entities/z.js
- *
- *  Copyright (c) 2010 Design Science, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-(function (MATHML) {
-  MathJax.Hub.Insert(MATHML.Parse.Entity,{
-    'ZHcy': '\u0416',
-    'Zacute': '\u0179',
-    'Zcaron': '\u017D',
-    'Zcy': '\u0417',
-    'Zdot': '\u017B',
-    'ZeroWidthSpace': '\u200B',
-    'zacute': '\u017A',
-    'zcaron': '\u017E',
-    'zcy': '\u0437',
-    'zdot': '\u017C',
-    'zeetrf': '\u2128',
-    'zhcy': '\u0436'
-  });
-
-  MathJax.Ajax.loadComplete(MATHML.entityDir+"/z.js");
-
-})(MathJax.InputJax.MathML);

lib/gollum/frontend/public/javascript/MathJax/jax/input/MathML/jax.js

@@ -1,590 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/input/MathML/jax.js
- *  
- *  Implements the MathML InputJax that reads mathematics in
- *  MathML format and converts it to the MML ElementJax
- *  internal format.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
-
- */
-
-(function (MATHML,BROWSER) {
-  var MML;
-  
-  MATHML.Parse = MathJax.Object.Subclass({
-
-    Init: function (string) {this.Parse(string)},
-    
-    //
-    //  Parse the MathML and check for errors
-    //
-    Parse: function (math) {
-      var doc;
-      if (typeof math !== "string") {doc = math.parentNode} else {
-        if (math.match(/^<[a-z]+:/i) && !math.match(/^<[^<>]* xmlns:/))
-          {math = math.replace(/^<([a-z]+):math/i,'<$1:math xmlns:$1="http://www.w3.org/1998/Math/MathML"')}
-        math = math.replace(/&([a-z]+);/ig,this.replaceEntity);
-        doc = MATHML.ParseXML(math); if (doc == null) {MATHML.Error("Error parsing MathML")}
-      }
-      var err = doc.getElementsByTagName("parsererror")[0];
-      if (err) MATHML.Error("Error parsing MathML: "+err.textContent.replace(/This page.*?errors:|XML Parsing Error: |Below is a rendering of the page.*/g,""));
-      if (doc.childNodes.length !== 1) MATHML.Error("MathML must be formed by a single element");
-      if (doc.firstChild.nodeName.toLowerCase() === "html") {
-        var h1 = doc.getElementsByTagName("h1")[0];
-        if (h1 && h1.textContent === "XML parsing error" && h1.nextSibling)
-          MATHML.Error("Error parsing MathML: "+String(h1.nextSibling.nodeValue).replace(/fatal parsing error: /,""));
-      }
-      if (doc.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") !== "math")
-        MATHML.Error("MathML must be formed by a <math> element, not <"+doc.firstChild.nodeName+">");
-      this.mml = this.MakeMML(doc.firstChild);
-    },
-    
-    //
-    //  Convert the MathML structure to the MathJax Element jax structure
-    //
-    MakeMML: function (node) {
-      var type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,"");
-      if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase)))
-        {return MML.merror("Unknown node type: "+type)}
-      var mml = MML[type](), i, m, value;
-      for (i = 0, m = node.attributes.length; i < m; i++) {
-        value = node.attributes[i].value;
-        if (value.toLowerCase() === "true") {value = true}
-          else if (value.toLowerCase() === "false") {value = false}
-        mml[node.attributes[i].name] = value;
-      }
-      for (i = 0, m = node.childNodes.length; i < m; i++) {
-        var child = node.childNodes[i];
-        if (child.nodeName === "#comment") continue;
-        if (child.nodeName === "#text") {
-          if (mml.isToken) {
-            var text = this.trimSpace(child.nodeValue);
-            if (mml.isa(MML.mo) && text.length === 1 && this.Remap[text.charAt(0)])
-              {text = this.Remap[text.charAt(0)]}
-            text = text.replace(/&([a-z]+);/ig,this.replaceEntity);
-            mml.Append(MML.chars(text));
-          } else if (child.nodeValue.match(/\S/)) {
-            MATHML.Error("Unexpected text node: '"+child.nodeValue+"'");
-          }
-        } else {mml.Append(this.MakeMML(child))}
-      }
-      if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08}
-      return mml;
-    },
-    
-    trimSpace: function (string) {
-      return string.replace(/^[ \t\n\r]+/,"")              // initial whitespace
-                   .replace(/[ \t\n\r]+$/,"")              // trailing whitespace
-                   .replace(/[ \t\n\r][ \t\n\r]+/g," ");   // internal multiple whitespace
-    },
-    
-    replaceEntity: function (match,entity) {
-      if (MATHML.Parse.Entity[entity]) {return MATHML.Parse.Entity[entity]}
-      var file = entity.charAt(0).toLowerCase();
-      var font = entity.match(/^[a-zA-Z](fr|scr|opf)$/);
-      if (font) {file = font[1]}
-      if (!MATHML.Parse.loaded[file]) {
-        MATHML.Parse.loaded[file] = true;
-        MathJax.Hub.RestartAfter(MathJax.Ajax.Require(MATHML.entityDir+"/"+file+".js"));
-      }
-      return match;
-    },
-    
-    Remap: {
-      '\u0027': '\u2032', // '
-      '\u002A': '\u2217', // *
-      '\u002D': '\u2212'  // -
-    }
-  }, {
-    loaded: []
-  });
-  
-  /************************************************************************/
-
-  MATHML.Augment({
-    Translate: function (script) {
-      var mml, math;
-      if (script.firstChild &&
-          script.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") === "math") {
-        math = this.prefilterMathML(script.firstChild);
-      } else {
-        math = script.innerHTML.replace(/^\s+/,"").replace(/\s+$/,"");
-        if (BROWSER.isMSIE) 
-          {math = math.replace(/(&nbsp;)+$/,"").replace(/&amp;/g,"&").replace(/&lt;/g,"&amp;lt;")}
-        else if (BROWSER.isKonqueror)
-          {math = math.replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&amp;/g,"&")}
-        math = this.prefilterMath(math,script);
-      }
-      try {
-        mml = MATHML.Parse(math).mml;
-      } catch(err) {
-        if (!err.mathmlError) {throw err}
-        mml = this.formatError(err,math,script);
-      }
-      return MML(mml);
-    },
-    prefilterMath: function (math,script) {return math},
-    prefilterMathML: function (math) {return math},
-    formatError: function (err,math,script) {
-      return MML.merror(err.message.replace(/\n.*/,""));
-    },
-    Error: function (message) {
-      throw MathJax.Hub.Insert(Error(message),{mathmlError: true});
-    },
-    //
-    //  Parsers for various forms (DOMParser, Windows ActiveX object, other)
-    //
-    parseDOM: function (string) {return this.parser.parseFromString(string,"text/xml")},
-    parseMS: function (string) {return (this.parser.loadXML(string) ? this.parser : null)},
-    parseDIV: function (string) {
-      this.div.innerHTML = string.replace(/<([a-z]+)([^>]*)\/>/g,"<$1$2></$1>");
-      return this.div;
-    },
-    //
-    //  Initialize the parser object (whichever type is used)
-    //
-    Startup: function () {
-      MML = MathJax.ElementJax.mml;
-      if (window.DOMParser) {
-        this.parser = new DOMParser();
-        this.ParseXML = this.parseDOM;
-      } else if (window.ActiveXObject) {
-        var xml = ["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.5.0","MSXML2.DOMDocument.4.0",
-                   "MSXML2.DOMDocument.3.0","MSXML2.DOMDocument.2.0","Microsoft.XMLDOM"];
-        for (var i = 0, m = xml.length; i < m && !this.parser; i++)
-          {try {this.parser = new ActiveXObject(xml[i])} catch (err) {}}
-        if (!this.parser) MATHML.Error("Can't create XML parser for MathML");
-        this.parser.async = false;
-        this.ParseXML = this.parseMS;
-      } else {
-        this.div = MathJax.Hub.Insert(document.createElement("div"),{
-             style:{visibility:"hidden", overflow:"hidden", height:"1px",
-                    position:"absolute", top:0}
-        });
-        if (!document.body.firstChild) {document.body.appendChild(this.div)}
-          else {document.body.insertBefore(this.div,document.body.firstChild)}
-        this.ParseXML = this.parseDIV;
-      }
-    }
-  });
-  
-  MATHML.Parse.Entity = {
-    ApplyFunction: '\u2061',
-    Backslash: '\u2216',
-    Because: '\u2235',
-    Breve: '\u02D8',
-    Cap: '\u22D2',
-    CenterDot: '\u00B7',
-    CircleDot: '\u2299',
-    CircleMinus: '\u2296',
-    CirclePlus: '\u2295',
-    CircleTimes: '\u2297',
-    Congruent: '\u2261',
-    ContourIntegral: '\u222E',
-    Coproduct: '\u2210',
-    Cross: '\u2A2F',
-    Cup: '\u22D3',
-    CupCap: '\u224D',
-    Dagger: '\u2021',
-    Del: '\u2207',
-    Delta: '\u0394',
-    Diamond: '\u22C4',
-    DifferentialD: '\u2146',
-    DotEqual: '\u2250',
-    DoubleDot: '\u00A8',
-    DoubleRightTee: '\u22A8',
-    DoubleVerticalBar: '\u2225',
-    DownArrow: '\u2193',
-    DownLeftVector: '\u21BD',
-    DownRightVector: '\u21C1',
-    DownTee: '\u22A4',
-    Downarrow: '\u21D3',
-    Element: '\u2208',
-    EqualTilde: '\u2242',
-    Equilibrium: '\u21CC',
-    Exists: '\u2203',
-    ExponentialE: '\u2147',
-    FilledVerySmallSquare: '\u25AA',
-    ForAll: '\u2200',
-    Gamma: '\u0393',
-    Gg: '\u22D9',
-    GreaterEqual: '\u2265',
-    GreaterEqualLess: '\u22DB',
-    GreaterFullEqual: '\u2267',
-    GreaterLess: '\u2277',
-    GreaterSlantEqual: '\u2A7E',
-    GreaterTilde: '\u2273',
-    Hacek: '\u02C7',
-    Hat: '\u005E',
-    HumpDownHump: '\u224E',
-    HumpEqual: '\u224F',
-    Im: '\u2111',
-    ImaginaryI: '\u2148',
-    Integral: '\u222B',
-    Intersection: '\u22C2',
-    InvisibleComma: '\u2063',
-    InvisibleTimes: '\u2062',
-    Lambda: '\u039B',
-    Larr: '\u219E',
-    LeftAngleBracket: '\u2329',
-    LeftArrow: '\u2190',
-    LeftArrowRightArrow: '\u21C6',
-    LeftCeiling: '\u2308',
-    LeftDownVector: '\u21C3',
-    LeftFloor: '\u230A',
-    LeftRightArrow: '\u2194',
-    LeftTee: '\u22A3',
-    LeftTriangle: '\u22B2',
-    LeftTriangleEqual: '\u22B4',
-    LeftUpVector: '\u21BF',
-    LeftVector: '\u21BC',
-    Leftarrow: '\u21D0',
-    Leftrightarrow: '\u21D4',
-    LessEqualGreater: '\u22DA',
-    LessFullEqual: '\u2266',
-    LessGreater: '\u2276',
-    LessSlantEqual: '\u2A7D',
-    LessTilde: '\u2272',
-    Ll: '\u22D8',
-    Lleftarrow: '\u21DA',
-    LongLeftArrow: '\u27F5',
-    LongLeftRightArrow: '\u27F7',
-    LongRightArrow: '\u27F6',
-    Longleftarrow: '\u27F8',
-    Longleftrightarrow: '\u27FA',
-    Longrightarrow: '\u27F9',
-    Lsh: '\u21B0',
-    MinusPlus: '\u2213',
-    NestedGreaterGreater: '\u226B',
-    NestedLessLess: '\u226A',
-    NotDoubleVerticalBar: '\u2226',
-    NotElement: '\u2209',
-    NotEqual: '\u2260',
-    NotExists: '\u2204',
-    NotGreater: '\u226F',
-    NotGreaterEqual: '\u2271',
-    NotLeftTriangle: '\u22EA',
-    NotLeftTriangleEqual: '\u22EC',
-    NotLess: '\u226E',
-    NotLessEqual: '\u2270',
-    NotPrecedes: '\u2280',
-    NotPrecedesSlantEqual: '\u22E0',
-    NotRightTriangle: '\u22EB',
-    NotRightTriangleEqual: '\u22ED',
-    NotSubsetEqual: '\u2288',
-    NotSucceeds: '\u2281',
-    NotSucceedsSlantEqual: '\u22E1',
-    NotSupersetEqual: '\u2289',
-    NotTilde: '\u2241',
-    NotVerticalBar: '\u2224',
-    Omega: '\u03A9',
-    OverBar: '\u00AF',
-    OverBrace: '\uFE37',
-    PartialD: '\u2202',
-    Phi: '\u03A6',
-    Pi: '\u03A0',
-    PlusMinus: '\u00B1',
-    Precedes: '\u227A',
-    PrecedesEqual: '\u2AAF',
-    PrecedesSlantEqual: '\u227C',
-    PrecedesTilde: '\u227E',
-    Product: '\u220F',
-    Proportional: '\u221D',
-    Psi: '\u03A8',
-    Rarr: '\u21A0',
-    Re: '\u211C',
-    ReverseEquilibrium: '\u21CB',
-    RightAngleBracket: '\u232A',
-    RightArrow: '\u2192',
-    RightArrowLeftArrow: '\u21C4',
-    RightCeiling: '\u2309',
-    RightDownVector: '\u21C2',
-    RightFloor: '\u230B',
-    RightTee: '\u22A2',
-    RightTeeArrow: '\u21A6',
-    RightTriangle: '\u22B3',
-    RightTriangleEqual: '\u22B5',
-    RightUpVector: '\u21BE',
-    RightVector: '\u21C0',
-    Rightarrow: '\u21D2',
-    Rrightarrow: '\u21DB',
-    Rsh: '\u21B1',
-    Sigma: '\u03A3',
-    SmallCircle: '\u2218',
-    Sqrt: '\u221A',
-    Square: '\u25A1',
-    SquareIntersection: '\u2293',
-    SquareSubset: '\u228F',
-    SquareSubsetEqual: '\u2291',
-    SquareSuperset: '\u2290',
-    SquareSupersetEqual: '\u2292',
-    SquareUnion: '\u2294',
-    Star: '\u22C6',
-    Subset: '\u22D0',
-    SubsetEqual: '\u2286',
-    Succeeds: '\u227B',
-    SucceedsEqual: '\u2AB0',
-    SucceedsSlantEqual: '\u227D',
-    SucceedsTilde: '\u227F',
-    SuchThat: '\u220B',
-    Sum: '\u2211',
-    Superset: '\u2283',
-    SupersetEqual: '\u2287',
-    Supset: '\u22D1',
-    Therefore: '\u2234',
-    Theta: '\u0398',
-    Tilde: '\u223C',
-    TildeEqual: '\u2243',
-    TildeFullEqual: '\u2245',
-    TildeTilde: '\u2248',
-    UnderBar: '\u0332',
-    UnderBrace: '\uFE38',
-    Union: '\u22C3',
-    UnionPlus: '\u228E',
-    UpArrow: '\u2191',
-    UpDownArrow: '\u2195',
-    UpTee: '\u22A5',
-    Uparrow: '\u21D1',
-    Updownarrow: '\u21D5',
-    Upsilon: '\u03A5',
-    Vdash: '\u22A9',
-    Vee: '\u22C1',
-    VerticalBar: '\u2223',
-    VerticalTilde: '\u2240',
-    Vvdash: '\u22AA',
-    Wedge: '\u22C0',
-    Xi: '\u039E',
-    acute: '\u00B4',
-    aleph: '\u2135',
-    alpha: '\u03B1',
-    amalg: '\u2A3F',
-    and: '\u2227',
-    ang: '\u2220',
-    angmsd: '\u2221',
-    angsph: '\u2222',
-    ape: '\u224A',
-    backprime: '\u2035',
-    backsim: '\u223D',
-    backsimeq: '\u22CD',
-    beta: '\u03B2',
-    beth: '\u2136',
-    between: '\u226C',
-    bigcirc: '\u25EF',
-    bigodot: '\u2A00',
-    bigoplus: '\u2A01',
-    bigotimes: '\u2A02',
-    bigsqcup: '\u2A06',
-    bigstar: '\u2605',
-    bigtriangledown: '\u25BD',
-    bigtriangleup: '\u25B3',
-    biguplus: '\u2A04',
-    blacklozenge: '\u29EB',
-    blacktriangle: '\u25B4',
-    blacktriangledown: '\u25BE',
-    blacktriangleleft: '\u25C2',
-    bowtie: '\u22C8',
-    boxdl: '\u2510',
-    boxdr: '\u250C',
-    boxminus: '\u229F',
-    boxplus: '\u229E',
-    boxtimes: '\u22A0',
-    boxul: '\u2518',
-    boxur: '\u2514',
-    bsol: '\u005C',
-    bull: '\u2022',
-    cap: '\u2229',
-    check: '\u2713',
-    chi: '\u03C7',
-    circ: '\u02C6',
-    circeq: '\u2257',
-    circlearrowleft: '\u21BA',
-    circlearrowright: '\u21BB',
-    circledR: '\u00AE',
-    circledS: '\u24C8',
-    circledast: '\u229B',
-    circledcirc: '\u229A',
-    circleddash: '\u229D',
-    clubs: '\u2663',
-    colon: '\u003A',
-    comp: '\u2201',
-    ctdot: '\u22EF',
-    cuepr: '\u22DE',
-    cuesc: '\u22DF',
-    cularr: '\u21B6',
-    cup: '\u222A',
-    curarr: '\u21B7',
-    curlyvee: '\u22CE',
-    curlywedge: '\u22CF',
-    dagger: '\u2020',
-    daleth: '\u2138',
-    ddarr: '\u21CA',
-    deg: '\u00B0',
-    delta: '\u03B4',
-    digamma: '\u03DD',
-    div: '\u00F7',
-    divideontimes: '\u22C7',
-    dot: '\u02D9',
-    doteqdot: '\u2251',
-    dotplus: '\u2214',
-    dotsquare: '\u22A1',
-    dtdot: '\u22F1',
-    ecir: '\u2256',
-    efDot: '\u2252',
-    egs: '\u2A96',
-    ell: '\u2113',
-    els: '\u2A95',
-    empty: '\u2205',
-    epsi: '\u03F5',
-    epsiv: '\u03B5',
-    erDot: '\u2253',
-    eta: '\u03B7',
-    eth: '\u00F0',
-    flat: '\u266D',
-    fork: '\u22D4',
-    frown: '\u2322',
-    gEl: '\u2A8C',
-    gamma: '\u03B3',
-    gap: '\u2A86',
-    gimel: '\u2137',
-    gnE: '\u2269',
-    gnap: '\u2A8A',
-    gne: '\u2A88',
-    gnsim: '\u22E7',
-    gt: '\u003E',
-    gtdot: '\u22D7',
-    harrw: '\u21AD',
-    hbar: '\u210F',
-    hellip: '\u2026',
-    hookleftarrow: '\u21A9',
-    hookrightarrow: '\u21AA',
-    imath: '\u0131',
-    infin: '\u221E',
-    intcal: '\u22BA',
-    iota: '\u03B9',
-    kappa: '\u03BA',
-    kappav: '\u03F0',
-    lEg: '\u2A8B',
-    lambda: '\u03BB',
-    lap: '\u2A85',
-    larrlp: '\u21AB',
-    larrtl: '\u21A2',
-    lbrace: '\u007B',
-    lbrack: '\u005B',
-    le: '\u2264',
-    leftleftarrows: '\u21C7',
-    leftthreetimes: '\u22CB',
-    lessdot: '\u22D6',
-    lmoust: '\u23B0',
-    lnE: '\u2268',
-    lnap: '\u2A89',
-    lne: '\u2A87',
-    lnsim: '\u22E6',
-    longmapsto: '\u27FC',
-    looparrowright: '\u21AC',
-    lowast: '\u2217',
-    lowbar: '\u005F',
-    loz: '\u25CA',
-    lt: '\u003C',
-    ltimes: '\u22C9',
-    ltri: '\u25C3',
-    malt: '\u2720',
-    mho: '\u2127',
-    mu: '\u03BC',
-    multimap: '\u22B8',
-    nVDash: '\u22AF',
-    nVdash: '\u22AE',
-    natur: '\u266E',
-    nearr: '\u2197',
-    nhArr: '\u21CE',
-    nharr: '\u21AE',
-    nlArr: '\u21CD',
-    nlarr: '\u219A',
-    not: '\u00AC',
-    nrArr: '\u21CF',
-    nrarr: '\u219B',
-    nu: '\u03BD',
-    nvDash: '\u22AD',
-    nvdash: '\u22AC',
-    nwarr: '\u2196',
-    omega: '\u03C9',
-    or: '\u2228',
-    osol: '\u2298',
-    period: '\u002E',
-    phi: '\u03D5',
-    phiv: '\u03C6',
-    pi: '\u03C0',
-    piv: '\u03D6',
-    prap: '\u2AB7',
-    precnapprox: '\u2AB9',
-    precneqq: '\u2AB5',
-    precnsim: '\u22E8',
-    prime: '\u2032',
-    psi: '\u03C8',
-    rarrtl: '\u21A3',
-    rbrace: '\u007D',
-    rbrack: '\u005D',
-    rho: '\u03C1',
-    rhov: '\u03F1',
-    rightrightarrows: '\u21C9',
-    rightthreetimes: '\u22CC',
-    ring: '\u02DA',
-    rmoust: '\u23B1',
-    rtimes: '\u22CA',
-    rtri: '\u25B9',
-    scap: '\u2AB8',
-    scnE: '\u2AB6',
-    scnap: '\u2ABA',
-    scnsim: '\u22E9',
-    sdot: '\u22C5',
-    searr: '\u2198',
-    sect: '\u00A7',
-    sharp: '\u266F',
-    sigma: '\u03C3',
-    sigmav: '\u03C2',
-    simne: '\u2246',
-    smile: '\u2323',
-    spades: '\u2660',
-    sub: '\u2282',
-    subE: '\u2AC5',
-    subnE: '\u2ACB',
-    subne: '\u228A',
-    supE: '\u2AC6',
-    supnE: '\u2ACC',
-    supne: '\u228B',
-    swarr: '\u2199',
-    tau: '\u03C4',
-    theta: '\u03B8',
-    thetav: '\u03D1',
-    tilde: '\u02DC',
-    times: '\u00D7',
-    triangle: '\u25B5',
-    triangleq: '\u225C',
-    upsi: '\u03C5',
-    upuparrows: '\u21C8',
-    veebar: '\u22BB',
-    vellip: '\u22EE',
-    weierp: '\u2118',
-    xi: '\u03BE',
-    yen: '\u00A5',
-    zeta: '\u03B6',
-    zigrarr: '\u21DD'
-  };
-  
-  MATHML.loadComplete("jax.js");
-  
-})(MathJax.InputJax.MathML,MathJax.Hub.Browser);

lib/gollum/frontend/public/javascript/MathJax/jax/input/TeX/config.js

@@ -1,40 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/input/TeX/config.js
- *
- *  Initializes the TeX InputJax (the main definition is in
- *  MathJax/jax/input/TeX/jax.js, which is loaded when needed).
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2009 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-MathJax.InputJax.TeX = MathJax.InputJax({
-  name: "TeX",
-  version: 1.0,
-  directory: MathJax.InputJax.directory + "/TeX",
-  extensionDir: MathJax.InputJax.extensionDir + "/TeX",
-  require: [MathJax.ElementJax.directory + "/mml/jax.js"],
-  
-  config: {
-    TagSide:       "right",
-    TagIndent:     "0.8em",
-    MultLineWidth: "85%"
-  }
-});
-MathJax.InputJax.TeX.Register("math/tex");
-
-MathJax.InputJax.TeX.loadComplete("config.js");

lib/gollum/frontend/public/javascript/MathJax/jax/output/HTML-CSS/autoload/menclose.js

@@ -1,61 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/autoload/menclose.js
- *  
- *  Implements the HTML-CSS output for <mencode> elements.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-(function (MML,HTMLCSS) {
-  
-  MML.menclose.Augment({
-    toHTML: function (span) {
-      var values = this.getValues("notation","thickness","padding");
-      if (values.thickness == null) {values.thickness = ".1em"}
-      if (values.padding == null)   {values.padding   = ".25em"}
-      var p = HTMLCSS.length2em(values.padding);
-      var t = HTMLCSS.length2em(values.thickness);
-      if (t !== 0 && t < 1.25/HTMLCSS.em) {t = 1.25/HTMLCSS.em}
-      var T = (HTMLCSS.msieBorderWidthBug ? 0 : t);
-      // FIXME:  handle other notations
-      span = this.HTMLcreateSpan(span);
-      var stack = HTMLCSS.createStack(span);
-      var base = HTMLCSS.createBox(stack), box = HTMLCSS.createBox(stack);
-      HTMLCSS.Measured(this.data[0].toHTML(base),base);
-      box.bbox = {w:base.bbox.w+2*(p+t), h:base.bbox.h+base.bbox.d+2*(p+t), d:0,
-                 lw:0, rw:base.bbox.w+2*(p+t)};
-      var frame = HTMLCSS.addElement(box,"span",{style:{
-        display:"inline-block", overflow:"hidden",
-        border:HTMLCSS.Em(t)+" solid",
-        width:HTMLCSS.Em(box.bbox.w-2*T), height:HTMLCSS.Em(box.bbox.h-2*T)
-      }});
-      if (HTMLCSS.msieInlineBlockAlignBug)
-        {frame.style.verticalAlign = HTMLCSS.Em(HTMLCSS.getHD(span.parentNode).d)}
-      HTMLCSS.placeBox(box,0,-p-t-base.bbox.d);
-      HTMLCSS.placeBox(base,p+t,0);
-      this.HTMLhandleSpace(span);
-      this.HTMLhandleColor(span);
-      return span;
-    }
-  });
-  
-  MathJax.Hub.Startup.signal.Post("HTML-CSS menclose Ready");
-  MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/menclose.js");
-  
-})(MathJax.ElementJax.mml,MathJax.OutputJax["HTML-CSS"]);
-

lib/gollum/frontend/public/javascript/MathJax/jax/output/HTML-CSS/autoload/mglyph.js

@@ -1,98 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/autoload/mglyph.js
- *  
- *  Implements the HTML-CSS output for <mglyph> elements.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-(function (MML,HTMLCSS) {
-  
-  MML.mglyph.Augment({
-    toHTML: function (span,variant) {
-      var values = this.getValues("src","width","height","valign","alt");
-      if (values.src === "") {
-        values = this.getValues("index");
-        variant = this.HTMLgetVariant();
-        if (values.index) {this.HTMLhandleVariant(span,variant,String.fromCharCode(values.index))}
-      } else {
-        if (!this.img) {this.img = MML.mglyph.GLYPH[values.src]}
-        if (!this.img) {
-          this.img = MML.mglyph.GLYPH[values.src] = {img: new Image(), status: "pending"};
-          var img = this.img.img;
-          img.onload = MathJax.CallBack(["HTMLimgLoaded",this]);
-          img.onerror = MathJax.CallBack(["HTMLimgError",this]);
-          img.src = values.src;
-          MathJax.Hub.RestartAfter(img.onload);
-        }
-        var SPAN = span;
-        if (this.img.status !== "OK") {
-          var span = HTMLCSS.addElement(span,"span",{className:"merror", style:{fontSize:"75%"}});
-          HTMLCSS.addText(span,"Bad mglyph: "+values.src);
-          span.bbox = {lw:0, w:span.offsetWidth/HTMLCSS.em, h:.8, d:.2};
-          span.bbox.rw = span.bbox.w;
-        } else {
-          span = this.HTMLcreateSpan(span);
-          img = HTMLCSS.addElement(span,"img",{src:values.src, alt:values.alt, title:values.alt});
-          if (values.width)  {
-            if (String(values.width).match(/^\s*-?\d+\s*$/)) {values.width += "px"}
-            img.style.width = HTMLCSS.Em(HTMLCSS.length2em(values.width,this.img.img.width/HTMLCSS.em));
-          }
-          if (values.height) {
-            if (String(values.height).match(/^\s*-?\d+\s*$/)) {values.height += "px"}
-            img.style.height = HTMLCSS.Em(HTMLCSS.length2em(values.height,this.img.img.height/HTMLCSS.em));
-          }
-          span.bbox.w = span.bbox.rw = img.offsetWidth/HTMLCSS.em;
-          span.bbox.h = img.offsetHeight/HTMLCSS.em;
-          if (values.valign) {
-            if (String(values.valign).match(/^\s*-?\d+\s*$/)) {values.valign += "px"}
-            span.bbox.d = -HTMLCSS.length2em(values.valign,this.img.img.height/HTMLCSS.em);
-            img.style.verticalAlign = HTMLCSS.Em(-span.bbox.d);
-            span.bbox.h -= span.bbox.d;
-          }
-        }
-        if (variant) {
-          if (!SPAN.bbox) {
-            SPAN.bbox = {w: span.bbox.w, h: span.bbox.h, d: span.bbox.d,
-                         rw: span.bbox.rw, lw: span.bbox.lw};
-          } else {
-            SPAN.bbox.w += span.bbox.w;
-            if (SPAN.bbox.w > SPAN.bbox.rw) {SPAN.bbox.rw = SPAN.bbox.w}
-            if (span.bbox.h > SPAN.bbox.h) {SPAN.bbox.h = span.bbox.h}
-            if (span.bbox.d > SPAN.bbox.d) {SPAN.bbox.d = span.bbox.d}
-          }
-        }
-      }
-      this.HTMLhandleSpace(span);
-      this.HTMLhandleColor(span);
-      return span;
-    },
-    HTMLimgLoaded: function (event,status) {
-      if (typeof(event) === "string") {status = event}
-      this.img.status = (status || "OK")
-    },
-    HTMLimgError: function () {this.img.img.onload("error")}
-  },{
-    GLYPH: {}    // global list of all loaded glyphs
-  });
-  
-  MathJax.Hub.Startup.signal.Post("HTML-CSS mglyph Ready");
-  MathJax.Ajax.loadComplete(HTMLCSS.autoloadDir+"/mglyph.js");
-  
-})(MathJax.ElementJax.mml,MathJax.OutputJax["HTML-CSS"]);
-

lib/gollum/frontend/public/javascript/MathJax/jax/output/HTML-CSS/autoload/ms.js

@@ -1,49 +0,0 @@
-/*************************************************************
- *
- *  MathJax/jax/output/HTML-CSS/autoload/ms.js
- *  
- *  Implements the HTML-CSS output for <ms> elements.
- *
- *  ---------------------------------------------------------------------
- *  
- *  Copyright (c) 2010 Design Science, Inc.
- * 
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-(function (MML) {
-  
-  MML.ms.Augment({
-    toHTML: function (span) {
-      span = this.HTMLhandleSize(this.HTMLcreateSpan(span));
-      var values = this.getValues("lquote","rquote");
-      var text = this.data.join("");  // FIXME:  handle mglyph?
-      var pattern = [];
-      if (values.lquote.length === 1) {pattern.push(this.HTMLquoteRegExp(values.lquote))}
-      if (values.rquote.length === 1) {pattern.push(this.HTMLquoteRegExp(values.rquote))}
-      if (pattern.length) {text = text.replace(RegExp("("+pattern.join("|")+")","g"),"\\$1")}
-      this.HTMLhandleVariant(span,this.HTMLgetVariant(),values.lquote+text+values.rquote);
-      this.HTMLhandleSpace(span);
-      this.HTMLhandleColor(span);
-    },
-    HTMLquoteRegExp: function (string) {
-      return string.replace(/([.*+?|{}()\[\]\\])/g,"\\$1");
-    }
-  });
-  MML.ms.prototype.defaults.fontfamily = 'monospace';
-  
-  MathJax.Hub.Startup.signal.Post("HTML-CSS ms Ready");
-  
-})(MathJax.ElementJax.mml);
-
-MathJax.Ajax.loadComplete(MathJax.OutputJax["HTML-CSS"].autoloadDir+"/ms.js");