update elements and fix some bugs

lib/src/prism/components/prism-core.js

 var _self = (typeof window !== 'undefined')
         ? window   // if in browser
         : (
                 (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
                 ? self // if in worker
                 : {}   // if in node js
         );
 
 /**
  * Prism: Lightweight, robust, elegant syntax highlighting
@@ skipping 122 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;
+}