gollum 2.0.0 → 2.1.0

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/worker/mirror.js

@@ -0,0 +1,43 @@
+define(function(require, exports, module) {
+"use strict";
+
+var Document = require("../document").Document;
+var lang = require("../lib/lang");
+    
+var Mirror = exports.Mirror = function(sender) {
+    this.sender = sender;
+    var doc = this.doc = new Document("");
+    
+    var deferredUpdate = this.deferredUpdate = lang.deferredCall(this.onUpdate.bind(this));
+    
+    var _self = this;
+    sender.on("change", function(e) {
+        doc.applyDeltas([e.data]);        
+        deferredUpdate.schedule(_self.$timeout);
+    });
+};
+
+(function() {
+    
+    this.$timeout = 500;
+    
+    this.setTimeout = function(timeout) {
+        this.$timeout = timeout;
+    };
+    
+    this.setValue = function(value) {
+        this.doc.setValue(value);
+        this.deferredUpdate.schedule(this.$timeout);
+    };
+    
+    this.getValue = function(callbackId) {
+        this.sender.callback(this.doc.getValue(), callbackId);
+    };
+    
+    this.onUpdate = function() {
+        // abstract method
+    };
+    
+}).call(Mirror.prototype);
+
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/worker/worker.js

@@ -0,0 +1,138 @@
+"no use strict";
+
+var console = {
+    log: function(msg) {
+        postMessage({type: "log", data: msg});
+    }
+};
+var window = {
+    console: console
+};
+
+var normalizeModule = function(parentId, moduleName) {
+    // normalize plugin requires
+    if (moduleName.indexOf("!") !== -1) {
+        var chunks = moduleName.split("!");
+        return normalizeModule(parentId, chunks[0]) + "!" + normalizeModule(parentId, chunks[1]);
+    }
+    // normalize relative requires
+    if (moduleName.charAt(0) == ".") {
+        var base = parentId.split("/").slice(0, -1).join("/");
+        var moduleName = base + "/" + moduleName;
+        
+        while(moduleName.indexOf(".") !== -1 && previous != moduleName) {
+            var previous = moduleName;
+            var moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
+        }
+    }
+    
+    return moduleName;
+};
+
+var require = function(parentId, id) {
+    var id = normalizeModule(parentId, id);
+    
+    var module = require.modules[id];
+    if (module) {
+        if (!module.initialized) {
+            module.exports = module.factory().exports;
+            module.initialized = true;
+        }
+        return module.exports;
+    }
+    
+    var chunks = id.split("/");
+    chunks[0] = require.tlns[chunks[0]] || chunks[0];
+    var path = chunks.join("/") + ".js";
+    
+    require.id = id;
+    importScripts(path);
+    return require(parentId, id);    
+};
+
+require.modules = {};
+require.tlns = {};
+
+var define = function(id, deps, factory) {
+    if (arguments.length == 2) {
+        factory = deps;
+    } else if (arguments.length == 1) {
+        factory = id;
+        id = require.id;
+    }
+
+    if (id.indexOf("text!") === 0) 
+        return;
+    
+    var req = function(deps, factory) {
+        return require(id, deps, factory);
+    };
+
+    require.modules[id] = {
+        factory: function() {
+            var module = {
+                exports: {}
+            };
+            var returnExports = factory(req, module.exports, module);
+            if (returnExports)
+                module.exports = returnExports;
+            return module;
+        }
+    };
+};
+
+function initBaseUrls(topLevelNamespaces) {
+    require.tlns = topLevelNamespaces;
+}
+
+function initSender() {
+
+    var EventEmitter = require(null, "ace/lib/event_emitter").EventEmitter;
+    var oop = require(null, "ace/lib/oop");
+    
+    var Sender = function() {};
+    
+    (function() {
+        
+        oop.implement(this, EventEmitter);
+                
+        this.callback = function(data, callbackId) {
+            postMessage({
+                type: "call",
+                id: callbackId,
+                data: data
+            });
+        };
+    
+        this.emit = function(name, data) {
+            postMessage({
+                type: "event",
+                name: name,
+                data: data
+            });
+        };
+        
+    }).call(Sender.prototype);
+    
+    return new Sender();
+}
+
+var main;
+var sender;
+
+onmessage = function(e) {
+    var msg = e.data;
+    if (msg.command) {
+        main[msg.command].apply(main, msg.args);
+    }
+    else if (msg.init) {        
+        initBaseUrls(msg.tlns);
+        require(null, "ace/lib/fixoldbrowsers");
+        sender = initSender();
+        var clazz = require(null, msg.module)[msg.classname];
+        main = new clazz(sender);
+    } 
+    else if (msg.event && sender) {
+        sender._emit(msg.event, msg.data);
+    }
+};

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/worker/worker_client.js

@@ -0,0 +1,176 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Ajax.org Code Editor (ACE).
+ *
+ * The Initial Developer of the Original Code is
+ * Ajax.org B.V.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *      Fabian Jakobs <fabian AT ajax DOT org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+"use strict";
+
+var oop = require("../lib/oop");
+var EventEmitter = require("../lib/event_emitter").EventEmitter;
+var config = require("../config");
+
+var WorkerClient = function(topLevelNamespaces, packagedJs, mod, classname) {
+
+    this.changeListener = this.changeListener.bind(this);
+
+    if (config.get("packaged")) {
+        this.$worker = new Worker(config.get("workerPath") + "/" + packagedJs);
+    }
+    else {
+        var workerUrl;
+        if (typeof require.supports !== "undefined" && require.supports.indexOf("ucjs2-pinf-0") >= 0) {
+            // We are running in the sourcemint loader.
+            workerUrl = require.nameToUrl("ace/worker/worker_sourcemint");
+        } else {
+            // We are running in RequireJS.
+            // nameToUrl is renamed to toUrl in requirejs 2
+            if (require.nameToUrl && !require.toUrl)
+                require.toUrl = require.nameToUrl;
+            workerUrl = this.$normalizePath(require.toUrl("ace/worker/worker", null, "_"));
+        }
+        this.$worker = new Worker(workerUrl);
+
+        var tlns = {};
+        for (var i=0; i<topLevelNamespaces.length; i++) {
+            var ns = topLevelNamespaces[i];
+            var path = this.$normalizePath(require.toUrl(ns, null, "_").replace(/.js$/, ""));
+
+            tlns[ns] = path;
+        }
+    }
+
+    this.$worker.postMessage({
+        init : true,
+        tlns: tlns,
+        module: mod,
+        classname: classname
+    });
+
+    this.callbackId = 1;
+    this.callbacks = {};
+
+    var _self = this;
+    this.$worker.onerror = function(e) {
+        window.console && console.log && console.log(e);
+        throw e;
+    };
+    this.$worker.onmessage = function(e) {
+        var msg = e.data;
+        switch(msg.type) {
+            case "log":
+                window.console && console.log && console.log(msg.data);
+                break;
+
+            case "event":
+                _self._emit(msg.name, {data: msg.data});
+                break;
+
+            case "call":
+                var callback = _self.callbacks[msg.id];
+                if (callback) {
+                    callback(msg.data);
+                    delete _self.callbacks[msg.id];
+                }
+                break;
+        }
+    };
+};
+
+(function(){
+
+    oop.implement(this, EventEmitter);
+
+    this.$normalizePath = function(path) {
+        path = path.replace(/^[a-z]+:\/\/[^\/]+/, ""); // Remove domain name and rebuild it
+        path = location.protocol + "//" + location.host
+            // paths starting with a slash are relative to the root (host)
+            + (path.charAt(0) == "/" ? "" : location.pathname.replace(/\/[^\/]*$/, ""))
+            + "/" + path.replace(/^[\/]+/, "");
+        return path;
+    };
+
+    this.terminate = function() {
+        this._emit("terminate", {});
+        this.$worker.terminate();
+        this.$worker = null;
+        this.$doc.removeEventListener("change", this.changeListener);
+        this.$doc = null;
+    };
+
+    this.send = function(cmd, args) {
+        this.$worker.postMessage({command: cmd, args: args});
+    };
+
+    this.call = function(cmd, args, callback) {
+        if (callback) {
+            var id = this.callbackId++;
+            this.callbacks[id] = callback;
+            args.push(id);
+        }
+        this.send(cmd, args);
+    };
+
+    this.emit = function(event, data) {
+        try {
+            // firefox refuses to clone objects which have function properties
+            // TODO: cleanup event
+            this.$worker.postMessage({event: event, data: {data: data.data}});
+        }
+        catch(ex) {}
+    };
+
+    this.attachToDocument = function(doc) {
+        if(this.$doc)
+            this.terminate();
+
+        this.$doc = doc;
+        this.call("setValue", [doc.getValue()]);
+        doc.on("change", this.changeListener);
+    };
+
+    this.changeListener = function(e) {
+        e.range = {
+            start: e.data.range.start,
+            end: e.data.range.end
+        };
+        this.emit("change", e);
+    };
+
+}).call(WorkerClient.prototype);
+
+exports.WorkerClient = WorkerClient;
+
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/worker/worker_sourcemint.js

@@ -0,0 +1,73 @@
+
+define(function(require, exports, module) {
+
+    "no use strict";
+
+    exports.main = function()
+    {
+        var console = {
+            log: function(msg) {
+                postMessage({type: "log", data: msg});
+            }
+        };
+
+        // NOTE: This sets the global `window` object used by workers.
+        // TODO: Pass into worker what it needs and don't set global here.
+        window = {
+            console: console
+        };
+
+        function initSender() {
+
+            var EventEmitter = require("ace/lib/event_emitter").EventEmitter;
+            var oop = require("ace/lib/oop");
+            
+            var Sender = function() {};
+            
+            (function() {
+                
+                oop.implement(this, EventEmitter);
+                        
+                this.callback = function(data, callbackId) {
+                    postMessage({
+                        type: "call",
+                        id: callbackId,
+                        data: data
+                    });
+                };
+            
+                this.emit = function(name, data) {
+                    postMessage({
+                        type: "event",
+                        name: name,
+                        data: data
+                    });
+                };
+                
+            }).call(Sender.prototype);
+            
+            return new Sender();
+        }
+
+        var main;
+        var sender;
+
+        onmessage = function(e) {
+            var msg = e.data;
+            if (msg.command) {
+                main[msg.command].apply(main, msg.args);
+            }
+            else if (msg.init) {        
+                require("ace/lib/fixoldbrowsers");
+                sender = initSender();
+                require.async(msg.module, function(WORKER) {
+                    var clazz = WORKER[msg.classname];
+                    main = new clazz(sender);
+                });
+            } 
+            else if (msg.event && sender) {
+                sender._emit(msg.event, msg.data);
+            }
+        };
+    }
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/jquery.ba-throttle-debounce.min.js

@@ -0,0 +1,2 @@
+(function(window,undefined){"$:nomunge";var $=window.jQuery||window.Cowboy||(window.Cowboy={}),jq_throttle;$.throttle=jq_throttle=function(delay,no_trailing,callback,debounce_mode){var timeout_id,last_exec=0;if(typeof no_trailing!=="boolean"){debounce_mode=callback;callback=no_trailing;no_trailing=undefined}function wrapper(){var that=this,elapsed=+new Date-last_exec,args=arguments;function exec(){last_exec=+new Date;callback.apply(that,args)}function clear(){timeout_id=undefined}if(debounce_mode&&
+!timeout_id)exec();timeout_id&&clearTimeout(timeout_id);if(debounce_mode===undefined&&elapsed>delay)exec();else if(no_trailing!==true)timeout_id=setTimeout(debounce_mode?clear:exec,debounce_mode===undefined?delay-elapsed:delay)}if($.guid)wrapper.guid=callback.guid=callback.guid||$.guid++;return wrapper};$.debounce=function(delay,at_begin,callback){return callback===undefined?jq_throttle(delay,at_begin,false):jq_throttle(delay,callback,at_begin!==false)}})(this);

data/lib/gollum/frontend/public/gollum/livepreview/js/livepreview.js

@@ -0,0 +1,456 @@
+require([ 'ace/undomanager', 'ace/ext/static_highlight', 'ace/theme/github', 'ace/editor', 'ace/virtual_renderer', 'ace/mode/markdown', 'ace/theme/twilight',
+'ace/mode/c_cpp', 'ace/mode/clojure', 'ace/mode/coffee', 'ace/mode/coldfusion', 'ace/mode/csharp', 'ace/mode/css', 'ace/mode/diff', 'ace/mode/golang', 'ace/mode/groovy', 'ace/mode/haxe', 'ace/mode/html', 'ace/mode/java', 'ace/mode/javascript', 'ace/mode/json', 'ace/mode/latex', 'ace/mode/less', 'ace/mode/liquid', 'ace/mode/lua', 'ace/mode/markdown', 'ace/mode/ocaml', 'ace/mode/perl', 'ace/mode/pgsql', 'ace/mode/php', 'ace/mode/powershell', 'ace/mode/python', 'ace/mode/ruby', 'ace/mode/scad', 'ace/mode/scala', 'ace/mode/scss', 'ace/mode/sh', 'ace/mode/sql', 'ace/mode/svg', 'ace/mode/textile', 'ace/mode/text', 'ace/mode/xml', 'ace/mode/xquery', 'ace/mode/yaml'
+], function() {
+var UndoManager = require("ace/undomanager").UndoManager;
+var Renderer = require( 'ace/virtual_renderer' ).VirtualRenderer;
+var Editor = require( 'ace/editor' ).Editor;
+var dom = require( 'ace/lib/dom' );
+
+var win = window;
+var location = win.location;
+var doc = document;
+
+win.onbeforeunload = function() { return 'Leaving Live Preview will discard all edits!' };
+
+var editor = new Editor( new Renderer( doc.getElementById( 'editor' ) ));//ace.edit( 'editor' );
+var editorSession = editor.getSession();
+$.editorSession = editorSession; // for testing
+var editorContainer = editor.container;
+var preview = doc.getElementById( 'previewframe' );
+var content = doc.getElementById( 'contentframe' );
+var toolPanel = doc.getElementById( 'toolpanel' );
+var comment = doc.getElementById( 'comment' );
+var commentToolPanel = doc.getElementById( 'commenttoolpanel' );
+// dim the page
+var darkness = doc.getElementById( 'darkness' );
+
+var leftRight = true;
+var jsm = {}; // JavaScript Markdown
+win.jsm = jsm;
+win.jsm.toggleLeftRight = function() {
+  leftRight = leftRight === false ? true : false;
+  jsm.resize();
+}
+
+var MarkdownMode = require( 'ace/mode/markdown' ).Mode;
+
+function initAce( editor, editorSession ) {
+  editorSession.setUndoManager(new UndoManager());
+  editor.setTheme( 'ace/theme/twilight' );
+  editorSession.setMode( new MarkdownMode() );
+  // Gutter shows line numbers
+  editor.renderer.setShowGutter( true );
+  editor.renderer.setHScrollBarAlwaysVisible( false );
+  editorSession.setUseSoftTabs( true );
+  editorSession.setTabSize( 2 );
+  editorSession.setUseWrapMode( true );
+  editor.setShowPrintMargin( false );
+  editor.setBehavioursEnabled( true );
+}
+
+initAce( editor, editorSession );
+
+// Setup comment ace.
+var commentEditor = new Editor( new Renderer( doc.getElementById( 'comment' ) ));//ace.edit( 'comment' );
+var commentEditorSession = commentEditor.getSession();
+$.commentSession = commentEditorSession; // for testing
+var commentEditorContainer = commentEditor.container;
+
+initAce( commentEditor, commentEditorSession );
+
+// Find the app's base url, knowing we are in /livepreview/index.html
+var baseUrl = location.pathname.split('/').slice(0,-2).join('/');
+
+// RegExp from http://stackoverflow.com/questions/901115/get-query-string-values-in-javascript
+$.key = function( key ) {
+    var value = new RegExp( '[\\?&]' + key + '=([^&#]*)' ).exec( location.href );
+    return  ( !value ) ? 0 : value[ 1 ] || 0;
+}
+
+// True if &create=true
+var create = $.key( 'create' );
+// The path and name of the page being edited.
+var pageName = $.key( 'page' );
+var pathName = $.key( 'path' );
+
+if ( pathName === 0 ) {
+  pathName = undefined;
+}
+
+defaultCommitMessage = function() {
+  var msg = pageName + ' (markdown)';
+
+  if (create) {
+    return 'Created ' + msg;
+  } else {
+    return 'Updated ' + msg;
+  }
+}
+
+// Set comment using the default commit message.
+commentEditorSession.setValue( defaultCommitMessage() );
+
+$.save = function( commitMessage ) {
+  win.onbeforeunload = null;
+
+  var POST = 'POST';
+  var markdown = 'markdown';
+  var txt = editorSession.getValue();
+  var msg = defaultCommitMessage();
+  var newLocation = location.protocol + '//' + location.host + baseUrl;
+
+  if (pathName) {
+    newLocation += '/' + pathName;
+  }
+
+  newLocation += '/' + pageName;
+
+  // if &create=true then handle create instead of edit.
+  if ( create ) {
+    jQuery.ajax( {
+      type: POST,
+      url: baseUrl + '/create',
+      data:  { path: pathName, page: pageName, format: markdown, content: txt, message: commitMessage || msg },
+      success: function() {
+        win.location = newLocation;
+      }
+  });
+  } else {
+    jQuery.ajax( {
+      type: POST,
+      url: baseUrl + '/edit/' + pageName,
+      data:  { path: pathName, page: pageName, format: markdown, content: txt, message:  commitMessage || msg },
+      success: function() {
+          win.location = newLocation;
+      }
+    });
+  } // end else
+}
+
+var elapsedTime;
+var oldInputText = '';
+
+// ---- from Markdown.Editor
+var timeout;
+
+var nonSuckyBrowserPreviewSet = function( text ) {
+  content.innerHTML = text;
+}
+
+// IE doesn't let you use innerHTML if the element is contained somewhere in a table
+// (which is the case for inline editing) -- in that case, detach the element, set the
+// value, and reattach. Yes, that *is* ridiculous.
+var ieSafePreviewSet = function( text ) {
+  var parent = content.parentNode;
+  var sibling = content.nextSibling;
+  parent.removeChild( content );
+  content.innerHTML = text;
+  if ( !sibling )
+    parent.appendChild( content );
+  else
+    parent.insertBefore( content, sibling );
+}
+
+var cssTextSet = function( element, css ){
+  element.style.cssText = css;
+}
+
+var cssAttrSet = function( element, css ){
+  element.setAttribute( 'style', css );
+}
+
+/*
+ Redefine the function based on browser support.
+ element - the element to set the css on
+ css     - a fully formed css string. ex: 'top: 0; left: 0;'
+
+ Avoid reflow by batching CSS changes.
+ http://dev.opera.com/articles/view/efficient-javascript/?page=3#stylechanges
+*/
+var cssSet = function( element, css ) {
+  if( typeof( element.style.cssText ) != 'undefined' ) {
+    cssTextSet( element, css );
+    cssSet = cssTextSet;
+  } else {
+    cssAttrSet( element, css );
+    cssSet = cssAttrSet;
+  }
+}
+
+var previewSet = function( text ) {
+  try {
+    nonSuckyBrowserPreviewSet( text );
+    previewSet = nonSuckyBrowserPreviewSet;
+  } catch ( e ) {
+    ieSafePreviewSet( text );
+    previewSet = ieSafePreviewSet;
+  }
+};
+
+// 'c', 'c++', 'cpp' are github specific and transformed to c_cpp for Ace.
+var languages = [ 'c', 'c++', 'cpp', 'clojure', 'coffee', 'coldfusion',
+ 'csharp', 'css', 'diff', 'golang', 'groovy', 'haxe', 'html',
+ 'java', 'javascript', 'json', 'latex', 'less', 'liquid',
+ 'lua', 'markdown', 'ocaml', 'perl', 'pgsql', 'php', 'powershell',
+ 'python', 'ruby', 'scad', 'scala', 'scss', 'sh', 'sql', 'svg',
+ 'textile', 'text', 'xml', 'xquery', 'yaml' ];
+
+var staticHighlight = require( 'ace/ext/static_highlight' );
+var githubTheme = require( 'ace/theme/github' );
+var langModes = {};
+
+(function() {
+var languagesLength = languages.length;
+for ( var a = 0; a < languagesLength; a++ ) {
+  var name = languages[ a ];
+  langModes[ name ] = false;
+}
+})();
+
+function getLang( language ) {
+  var mode = langModes[ language ];
+
+  if ( mode ) {
+    return mode;
+  }
+
+  // require.Mode must be wrapped in parens.
+  mode = new ( require( 'ace/mode/' + language ).Mode )();
+
+  return mode;
+}
+
+function highlight( element, language ) {
+  // Highlighting requires .innerText not
+  // .innerHTML. It's the difference between
+  // '>' and '&gt;'.
+  // Firefox does not support innerText.
+  var data = element.innerText || element.textContent;
+  data = data.trim();
+  var mode = getLang( language );
+  // input, mode, theme, lineStart, disableGutter
+  var color = staticHighlight.render( data, mode, githubTheme, 1, true );
+
+  var newDiv = doc.createElement('div');
+  newDiv.innerHTML = color.html;
+  element.parentNode.parentNode.replaceChild( newDiv, element.parentNode );
+}
+
+var makePreviewHtml = function () {
+  var text = editorSession.getValue();
+
+  if ( text == undefined || text == '' ) {
+    previewSet( '' );
+    return;
+  }
+
+  if (text && text == oldInputText) {
+    return; // Input text hasn't changed.
+  }
+  else {
+    oldInputText = text;
+  }
+
+  var prevTime = new Date().getTime();
+  text = md_to_html( text );
+
+  // Calculate the processing time of the HTML creation.
+  // It's used as the delay time in the event listener.
+  var currTime = new Date().getTime();
+  elapsedTime = currTime - prevTime;
+
+  // Update the text using feature detection to support IE.
+  // preview.innerHTML = text; // this doesn't work on IE.
+  previewSet( text );
+  // MathJax is loaded asynchronously.
+  if (typeof MathJax != 'undefined') { MathJax.Hub.Typeset( content ); }
+
+  // highlight code blocks.
+  var codeElements = preview.getElementsByTagName( 'pre' );
+  var codeElementsLength = codeElements.length;
+  var skipped = 0;
+
+  if ( codeElementsLength > 0 ) {
+    for ( var idx = 0; idx < codeElementsLength; idx++ ) {
+      // highlight removes an element so 0 is always the correct index.
+      // Skipped tags are not removed so they must be added.
+      var element = codeElements[ 0 + skipped ].firstChild;
+      if ( element == undefined ) {
+        skipped++;
+        continue;
+      }
+      var codeHTML = element.innerHTML;
+      if ( codeHTML == undefined ) {
+        skipped++;
+        continue;
+      }
+      var txt = codeHTML.split( /\b/ );
+      // the syntax for code highlighting means all code, even one line, contains newlines.
+      if ( txt.length > 1 && codeHTML.match( /\n/ ) ) {
+        var declaredLanguage = element.className.toLowerCase();
+        var aceMode = declaredLanguage;
+
+        // GitHub supports 'c', 'c++', 'cpp'
+        // which must trigger the 'c_cpp' mode in Ace.
+        if ( declaredLanguage === 'c'   ||
+             declaredLanguage === 'c++' ||
+             declaredLanguage === 'cpp' ) {
+          aceMode = 'c_cpp';
+        }
+
+        if ( $.inArray( declaredLanguage, languages ) === -1 ) {
+          // Unsupported language.
+          skipped++;
+          continue;
+        }
+        // highlight: element
+        highlight( element, aceMode );
+      } else {
+        // Highlighting is not for `code` inline syntax. For example `puts "string"`.
+        skipped++;
+      }
+    }
+  }
+};
+
+// setTimeout is already used.  Used as an event listener.
+var applyTimeout = function () {
+  if ( timeout ) {
+    clearTimeout(timeout);
+    timeout = undefined;
+  }
+
+  // 3 second max delay
+  if ( elapsedTime > 3000 ) {
+    elapsedTime = 3000;
+  }
+
+  timeout = setTimeout( makePreviewHtml, elapsedTime );
+};
+
+  /* Load markdown from /data/page into the ace editor.
+     ~-1 == false; !~-1 == true;
+   */
+  if ( !~location.host.indexOf('github.com') ) {
+    jQuery.ajax( {
+      type: 'GET',
+      url: baseUrl + '/data/' + $.key( 'page' ),
+      success: function( data ) {
+         editorSession.setValue( data );
+      }
+    });
+  }
+
+  $( '#save' ).click( function() {
+    $.save();
+  });
+
+  // Hide dimmer, comment tool panel, and comment.
+  $( '#commentcancel' ).click( function() {
+    // Restore focus on commentcancel but not on
+    // savecommentconfirm because the latter loads
+    // a new page.
+    hideCommentWindow();
+    editor.focus();
+  });
+
+  var isCommentHidden = true;
+
+  // var style = darkness.style.visibility will not update visibility.
+  var darknessStyle = darkness.style;
+  var commentToolPanelStyle = commentToolPanel.style;
+  var commentStyle = comment.style;
+
+  function hideCommentWindow() {
+    isCommentHidden = true;
+    darknessStyle.visibility =
+    commentToolPanelStyle.visibility =
+    commentStyle.visibility = 'hidden';
+  }
+
+  // Show dimmer, comment tool panel, and comment.
+  $( '#savecomment' ).click( function() {
+    isCommentHidden = false;
+    darknessStyle.visibility =
+    commentToolPanelStyle.visibility =
+    commentStyle.visibility = 'visible';
+    // Set focus so typing can begin immediately.
+    commentEditor.focus();
+  });
+
+  $( '#savecommentconfirm' ).click( function() {
+    $.save( commentEditorSession.getValue() );
+    hideCommentWindow();
+  });
+
+  // onChange calls applyTimeout which rate limits the calling of makePreviewHtml based on render time.
+  editor.on( 'change', applyTimeout );
+  makePreviewHtml(); // preview default text on load
+
+  function resize() {
+    var width = $( win ).width();
+    var widthHalf = width / 2;
+    var widthFourth = widthHalf / 2;
+    var height = $( win ).height();
+    var heightHalf = height / 2;
+
+    // height minus 50 so the end of document text doesn't flow off the page.
+    var editorContainerStyle = 'width:' + widthHalf + 'px;' +
+      'height:' + (height - 50) + 'px;' +
+      'left:' + (leftRight === false ? widthHalf + 'px;' : '0px;') +
+      'top:' + '40px;'; // use 40px for tool menu
+    cssSet( editorContainer, editorContainerStyle );
+    editor.resize();
+
+    // width -2 for scroll bar & -10 for left offset
+    var previewStyle = 'width:' + (widthHalf - 2 - 10) + 'px;' +
+      'height:' + height + 'px;' +
+      'left:' + (leftRight === false ? '10px;' : widthHalf + 'px;') +
+      'top:' + '0px;';
+    cssSet( preview, previewStyle );
+
+     // Resize tool panel
+    var toolPanelStyle = 'width:' + widthHalf + 'px;' +
+      'left:' + (leftRight === false ? widthHalf + 'px;' : '0px;');
+    cssSet( toolPanel, toolPanelStyle );
+
+    // Resize comment related elements.
+    var commentHidden = 'visibility:' + ( isCommentHidden === true ? 'hidden;' : 'visible;' );
+
+    // Adjust comment editor
+    var commentEditorContainerStyle = 'height:' + heightHalf + 'px;' +
+      'width:' + widthHalf + 'px;' +
+      'left:' + widthFourth + 'px;' +
+      'top:' + (heightHalf / 2) + 'px;' +
+      commentHidden;
+    cssSet( commentEditorContainer, commentEditorContainerStyle );
+    commentEditor.resize();
+
+    // In top subtract height (40px) of comment tool panel.
+    var commentToolPanelStyle = 'width:' + widthHalf + 'px;' +
+      'left:' + widthFourth + 'px;' +
+      'top:' + (height / 4 - 40) + 'px;' +
+      commentHidden;
+    cssSet( commentToolPanel, commentToolPanelStyle );
+
+    // Resize dimmer.
+    var darknessStyle = 'width:' + width + 'px;' +
+      'height:' + height + 'px;' +
+      commentHidden;
+    cssSet( darkness, darknessStyle );
+  }
+
+  win.jsm.resize = resize;
+
+  /*
+     Resize can be called an absurd amount of times
+     and will crash the page without debouncing.
+     http://benalman.com/projects/jquery-throttle-debounce-plugin/
+     https://github.com/cowboy/jquery-throttle-debounce
+     http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
+  */
+  $( win ).resize( $.debounce( 100, resize ) );
+
+  // resize for the intial page load
+  resize();
+});