update elements and fix some bugs

lib/src/prism/prism.js

 
 /* **********************************************
      Begin prism-core.js
 ********************************************** */
 
 var _self = (typeof window !== 'undefined')
         ? window   // if in browser
         : (
                 (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
                 ? self // if in worker
@@ skipping 127 matching lines @@
                                         if (_.util.type(o[i]) === 'Object') {
                                                 _.languages.DFS(o[i], callback);
                                         }
                                         else if (_.util.type(o[i]) === 'Array') {
                                                 _.languages.DFS(o[i], callback, i);
                                         }
                                 }
                         }
                 }
         },
-
+        plugins: {},
+        
         highlightAll: function(async, callback) {
                 var elements = document.querySelectorAll('code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code');
 
                 for (var i=0, element; element = elements[i++];) {
                         _.highlightElement(element, async === true, callback);
                 }
         },
 
         highlightElement: function(element, async, callback) {
                 // Find language
@@ skipping 11 matching lines @@
                 // Set language on the element, if not present
                 element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
 
                 // Set language on the parent, for styling
                 parent = element.parentNode;
 
                 if (/pre/i.test(parent.nodeName)) {
                         parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
                 }
 
-                if (!grammar) {
-                        return;
-                }
-
                 var code = element.textContent;
 
-                if(!code) {
-                        return;
-                }
-
-                code = code.replace(/^(?:\r?\n|\r)/,'');
-
                 var env = {
                         element: element,
                         language: language,
                         grammar: grammar,
                         code: code
                 };
 
+                if (!code || !grammar) {
+                        _.hooks.run('complete', env);
+                        return;
+                }
+
                 _.hooks.run('before-highlight', env);
 
                 if (async && _self.Worker) {
                         var worker = new Worker(_.filename);
 
                         worker.onmessage = function(evt) {
-                                env.highlightedCode = Token.stringify(JSON.parse(evt.data), language);
+                                env.highlightedCode = evt.data;
 
                                 _.hooks.run('before-insert', env);
 
                                 env.element.innerHTML = env.highlightedCode;
 
                                 callback && callback.call(env.element);
                                 _.hooks.run('after-highlight', env);
+                                _.hooks.run('complete', env);
                         };
 
                         worker.postMessage(JSON.stringify({
                                 language: env.language,
-                                code: env.code
+                                code: env.code,
+                                immediateClose: true
                         }));
                 }
                 else {
                         env.highlightedCode = _.highlight(env.code, env.grammar, env.language);
 
                         _.hooks.run('before-insert', env);
 
                         env.element.innerHTML = env.highlightedCode;
 
                         callback && callback.call(element);
 
                         _.hooks.run('after-highlight', env);
+                        _.hooks.run('complete', env);
                 }
         },
 
         highlight: function (text, grammar, language) {
                 var tokens = _.tokenize(text, grammar);
                 return Token.stringify(_.util.encode(tokens), language);
         },
 
         tokenize: function(text, grammar, language) {
                 var Token = _.Token;
@@ skipping 138 matching lines @@
         if (o.alias) {
                 var aliases = _.util.type(o.alias) === 'Array' ? o.alias : [o.alias];
                 Array.prototype.push.apply(env.classes, aliases);
         }
 
         _.hooks.run('wrap', env);
 
         var attributes = '';
 
         for (var name in env.attributes) {
-                attributes += name + '="' + (env.attributes[name] || '') + '"';
+                attributes += (attributes ? ' ' : '') + name + '="' + (env.attributes[name] || '') + '"';
         }
 
         return '<' + env.tag + ' class="' + env.classes.join(' ') + '" ' + attributes + '>' + env.content + '</' + env.tag + '>';
 
 };
 
 if (!_self.document) {
         if (!_self.addEventListener) {
                 // in Node.js
                 return _self.Prism;
         }
         // In worker
         _self.addEventListener('message', function(evt) {
                 var message = JSON.parse(evt.data),
                     lang = message.language,
-                    code = message.code;
+                    code = message.code,
+                    immediateClose = message.immediateClose;
 
-                _self.postMessage(JSON.stringify(_.util.encode(_.tokenize(code, _.languages[lang]))));
-                _self.close();
+                _self.postMessage(_.highlight(code, _.languages[lang], lang));
+                if (immediateClose) {
+                        _self.close();
+                }
         }, false);
 
         return _self.Prism;
 }
 
 // Get current script and highlight
 var script = document.getElementsByTagName('script');
 
 script = script[script.length - 1];
 
 if (script) {
         _.filename = script.src;
 
         if (document.addEventListener && !script.hasAttribute('data-manual')) {
                 document.addEventListener('DOMContentLoaded', _.highlightAll);
         }
 }
 
 return _self.Prism;
 
 })();
 
 if (typeof module !== 'undefined' && module.exports) {
         module.exports = Prism;
 }
 
+// hack for components to work correctly in node.js
+if (typeof global !== 'undefined') {
+        global.Prism = Prism;
+}
+
 
 /* **********************************************
      Begin prism-markup.js
 ********************************************** */
 
 Prism.languages.markup = {
         'comment': /<!--[\w\W]*?-->/,
         'prolog': /<\?[\w\W]+?\?>/,
         'doctype': /<!DOCTYPE[\w\W]+?>/,
         'cdata': /<!\[CDATA\[[\w\W]*?]]>/i,
         'tag': {
-                pattern: /<\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\w\W])*\1|[^\s'">=]+))?)*\s*\/?>/i,
+                pattern: /<\/?[^\s>\/=.]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\\1|\\?(?!\1)[\w\W])*\1|[^\s'">=]+))?)*\s*\/?>/i,
                 inside: {
                         'tag': {
                                 pattern: /^<\/?[^\s>\/]+/i,
                                 inside: {
                                         'punctuation': /^<\/?/,
                                         'namespace': /^[^\s>\/:]+:/
                                 }
                         },
                         'attr-value': {
                                 pattern: /=(?:('|")[\w\W]*?(\1)|[^\s>]+)/i,
@@ skipping 15 matching lines @@
 };
 
 // Plugin to make entity title show the real entity, idea by Roman Komarov
 Prism.hooks.add('wrap', function(env) {
 
         if (env.type === 'entity') {
                 env.attributes['title'] = env.content.replace(/&amp;/, '&');
         }
 });
 
+Prism.languages.xml = Prism.languages.markup;
+Prism.languages.html = Prism.languages.markup;
+Prism.languages.mathml = Prism.languages.markup;
+Prism.languages.svg = Prism.languages.markup;
+
 
 /* **********************************************
      Begin prism-css.js
 ********************************************** */
 
 Prism.languages.css = {
         'comment': /\/\*[\w\W]*?\*\//,
         'atrule': {
                 pattern: /@[\w-]+?.*?(;|(?=\s*\{))/i,
                 inside: {
                         'rule': /@[\w-]+/
                         // See rest below
                 }
         },
         'url': /url\((?:(["'])(\\(?:\r\n|[\w\W])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,
         'selector': /[^\{\}\s][^\{\};]*?(?=\s*\{)/,
         'string': /("|')(\\(?:\r\n|[\w\W])|(?!\1)[^\\\r\n])*\1/,
         'property': /(\b|\B)[\w-]+(?=\s*:)/i,
         'important': /\B!important\b/i,
         'function': /[-a-z0-9]+(?=\()/i,
         'punctuation': /[(){};:]/
 };
 
 Prism.languages.css['atrule'].inside.rest = Prism.util.clone(Prism.languages.css);
 
 if (Prism.languages.markup) {
         Prism.languages.insertBefore('markup', 'tag', {
                 'style': {
-                        pattern: /<style[\w\W]*?>[\w\W]*?<\/style>/i,
-                        inside: {
-                                'tag': {
-                                        pattern: /<style[\w\W]*?>|<\/style>/i,
-                                        inside: Prism.languages.markup.tag.inside
-                                },
-                                rest: Prism.languages.css
-                        },
+                        pattern: /(<style[\w\W]*?>)[\w\W]*?(?=<\/style>)/i,
+                        lookbehind: true,
+                        inside: Prism.languages.css,
                         alias: 'language-css'
                 }
         });
         
         Prism.languages.insertBefore('inside', 'attr-value', {
                 'style-attr': {
                         pattern: /\s*style=("|').*?\1/i,
                         inside: {
                                 'attr-name': {
                                         pattern: /^\s*style/i,
@@ skipping 18 matching lines @@
         'comment': [
                 {
                         pattern: /(^|[^\\])\/\*[\w\W]*?\*\//,
                         lookbehind: true
                 },
                 {
                         pattern: /(^|[^\\:])\/\/.*/,
                         lookbehind: true
                 }
         ],
-        'string': /("|')(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        'string': /(["'])(\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
         'class-name': {
-                pattern: /((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/i,
+                pattern: /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/i,
                 lookbehind: true,
                 inside: {
                         punctuation: /(\.|\\)/
                 }
         },
         'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
         'boolean': /\b(true|false)\b/,
         'function': /[a-z0-9_]+(?=\()/i,
-        'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/,
-        'operator': /[-+]{1,2}|!|<=?|>=?|={1,3}|&{1,2}|\|?\||\?|\*|\/|~|\^|%/,
+        'number': /\b-?(?:0x[\da-f]+|\d*\.?\d+(?:e[+-]?\d+)?)\b/i,
+        'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
         'punctuation': /[{}[\];(),.:]/
 };
 
 
 /* **********************************************
      Begin prism-javascript.js
 ********************************************** */
 
 Prism.languages.javascript = Prism.languages.extend('clike', {
         'keyword': /\b(as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/,
         'number': /\b-?(0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d*\.?\d+([Ee][+-]?\d+)?|NaN|Infinity)\b/,
-        'function': /(?!\d)[a-z0-9_$]+(?=\()/i
+        // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+        'function': /[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*(?=\()/i
 });
 
 Prism.languages.insertBefore('javascript', 'keyword', {
         'regex': {
                 pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\\\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})]))/,
                 lookbehind: true
         }
 });
 
 Prism.languages.insertBefore('javascript', 'class-name', {
@@ skipping 11 matching lines @@
                                 }
                         },
                         'string': /[\s\S]+/
                 }
         }
 });
 
 if (Prism.languages.markup) {
         Prism.languages.insertBefore('markup', 'tag', {
                 'script': {
-                        pattern: /<script[\w\W]*?>[\w\W]*?<\/script>/i,
-                        inside: {
-                                'tag': {
-                                        pattern: /<script[\w\W]*?>|<\/script>/i,
-                                        inside: Prism.languages.markup.tag.inside
-                                },
-                                rest: Prism.languages.javascript
-                        },
+                        pattern: /(<script[\w\W]*?>)[\w\W]*?(?=<\/script>)/i,
+                        lookbehind: true,
+                        inside: Prism.languages.javascript,
                         alias: 'language-javascript'
                 }
         });
 }
 
+Prism.languages.js = Prism.languages.javascript;
 
 /* **********************************************
      Begin prism-file-highlight.js
 ********************************************** */
 
 (function () {
-        if (!self.Prism || !self.document || !document.querySelector) {
+        if (typeof self === 'undefined' || !self.Prism || !self.document || !document.querySelector) {
                 return;
         }
 
         self.Prism.fileHighlight = function() {
 
                 var Extensions = {
                         'js': 'javascript',
                         'html': 'markup',
                         'svg': 'markup',
                         'xml': 'markup',
@@ skipping 54 matching lines @@
 
                                 xhr.send(null);
                         });
                 }
 
         };
 
         self.Prism.fileHighlight();
 
 })();