wunderbar 0.18.3 → 0.19.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (32) hide show
  1. data/README.md +6 -0
  2. data/lib/wunderbar/{angular-resource.rb → angularjs/resource.rb} +1 -1
  3. data/lib/wunderbar/{angular-route.rb → angularjs/route.rb} +1 -1
  4. data/lib/wunderbar/angularjs.rb +1 -1
  5. data/lib/wunderbar/asset.rb +17 -6
  6. data/lib/wunderbar/builder.rb +8 -11
  7. data/lib/wunderbar/cgi-methods.rb +4 -5
  8. data/lib/wunderbar/cssproxy.rb +4 -0
  9. data/lib/wunderbar/html-methods.rb +9 -5
  10. data/lib/wunderbar/job-control.rb +2 -0
  11. data/lib/wunderbar/jquery/stupidtable.rb +5 -0
  12. data/lib/wunderbar/jquery.rb +2 -1
  13. data/lib/wunderbar/markdown.rb +1 -0
  14. data/lib/wunderbar/node.rb +34 -12
  15. data/lib/wunderbar/{opal-browser.rb → opal/browser.rb} +0 -0
  16. data/lib/wunderbar/{opal-jquery.rb → opal/jquery.rb} +0 -0
  17. data/lib/wunderbar/pagedown.rb +5 -0
  18. data/lib/wunderbar/polymer.rb +1 -1
  19. data/lib/wunderbar/script.rb +16 -3
  20. data/lib/wunderbar/sinatra.rb +7 -2
  21. data/lib/wunderbar/vendor/Markdown.Converter.js +1412 -0
  22. data/lib/wunderbar/{angular-resource.min.js → vendor/angular-resource.min.js} +0 -0
  23. data/lib/wunderbar/{angular-route.min.js → vendor/angular-route.min.js} +0 -0
  24. data/lib/wunderbar/{angular.min.js → vendor/angular.min.js} +0 -0
  25. data/lib/wunderbar/{jquery-1.10.2.min.js → vendor/jquery-1.10.2.min.js} +0 -0
  26. data/lib/wunderbar/{polymer-v0.0.20131003.min.js → vendor/polymer-v0.0.20131003.min.js} +0 -0
  27. data/lib/wunderbar/vendor/stupidtable.min.js +1 -0
  28. data/lib/wunderbar/version.rb +2 -2
  29. data/lib/wunderbar/websocket.rb +1 -1
  30. data/lib/wunderbar.rb +0 -1
  31. data/wunderbar.gemspec +3 -3
  32. metadata +17 -13
@@ -0,0 +1,1412 @@
1
+ var Markdown;
2
+
3
+ if (typeof exports === "object" && typeof require === "function") // we're in a CommonJS (e.g. Node.js) module
4
+ Markdown = exports;
5
+ else
6
+ Markdown = {};
7
+
8
+ // The following text is included for historical reasons, but should
9
+ // be taken with a pinch of salt; it's not all true anymore.
10
+
11
+ //
12
+ // Wherever possible, Showdown is a straight, line-by-line port
13
+ // of the Perl version of Markdown.
14
+ //
15
+ // This is not a normal parser design; it's basically just a
16
+ // series of string substitutions. It's hard to read and
17
+ // maintain this way, but keeping Showdown close to the original
18
+ // design makes it easier to port new features.
19
+ //
20
+ // More importantly, Showdown behaves like markdown.pl in most
21
+ // edge cases. So web applications can do client-side preview
22
+ // in Javascript, and then build identical HTML on the server.
23
+ //
24
+ // This port needs the new RegExp functionality of ECMA 262,
25
+ // 3rd Edition (i.e. Javascript 1.5). Most modern web browsers
26
+ // should do fine. Even with the new regular expression features,
27
+ // We do a lot of work to emulate Perl's regex functionality.
28
+ // The tricky changes in this file mostly have the "attacklab:"
29
+ // label. Major or self-explanatory changes don't.
30
+ //
31
+ // Smart diff tools like Araxis Merge will be able to match up
32
+ // this file with markdown.pl in a useful way. A little tweaking
33
+ // helps: in a copy of markdown.pl, replace "#" with "//" and
34
+ // replace "$text" with "text". Be sure to ignore whitespace
35
+ // and line endings.
36
+ //
37
+
38
+
39
+ //
40
+ // Usage:
41
+ //
42
+ // var text = "Markdown *rocks*.";
43
+ //
44
+ // var converter = new Markdown.Converter();
45
+ // var html = converter.makeHtml(text);
46
+ //
47
+ // alert(html);
48
+ //
49
+ // Note: move the sample code to the bottom of this
50
+ // file before uncommenting it.
51
+ //
52
+
53
+ (function () {
54
+
55
+ function identity(x) { return x; }
56
+ function returnFalse(x) { return false; }
57
+
58
+ function HookCollection() { }
59
+
60
+ HookCollection.prototype = {
61
+
62
+ chain: function (hookname, func) {
63
+ var original = this[hookname];
64
+ if (!original)
65
+ throw new Error("unknown hook " + hookname);
66
+
67
+ if (original === identity)
68
+ this[hookname] = func;
69
+ else
70
+ this[hookname] = function (text) {
71
+ var args = Array.prototype.slice.call(arguments, 0);
72
+ args[0] = original.apply(null, args);
73
+ return func.apply(null, args);
74
+ };
75
+ },
76
+ set: function (hookname, func) {
77
+ if (!this[hookname])
78
+ throw new Error("unknown hook " + hookname);
79
+ this[hookname] = func;
80
+ },
81
+ addNoop: function (hookname) {
82
+ this[hookname] = identity;
83
+ },
84
+ addFalse: function (hookname) {
85
+ this[hookname] = returnFalse;
86
+ }
87
+ };
88
+
89
+ Markdown.HookCollection = HookCollection;
90
+
91
+ // g_urls and g_titles allow arbitrary user-entered strings as keys. This
92
+ // caused an exception (and hence stopped the rendering) when the user entered
93
+ // e.g. [push] or [__proto__]. Adding a prefix to the actual key prevents this
94
+ // (since no builtin property starts with "s_"). See
95
+ // http://meta.stackoverflow.com/questions/64655/strange-wmd-bug
96
+ // (granted, switching from Array() to Object() alone would have left only __proto__
97
+ // to be a problem)
98
+ function SaveHash() { }
99
+ SaveHash.prototype = {
100
+ set: function (key, value) {
101
+ this["s_" + key] = value;
102
+ },
103
+ get: function (key) {
104
+ return this["s_" + key];
105
+ }
106
+ };
107
+
108
+ Markdown.Converter = function () {
109
+ var pluginHooks = this.hooks = new HookCollection();
110
+
111
+ // given a URL that was encountered by itself (without markup), should return the link text that's to be given to this link
112
+ pluginHooks.addNoop("plainLinkText");
113
+
114
+ // called with the orignal text as given to makeHtml. The result of this plugin hook is the actual markdown source that will be cooked
115
+ pluginHooks.addNoop("preConversion");
116
+
117
+ // called with the text once all normalizations have been completed (tabs to spaces, line endings, etc.), but before any conversions have
118
+ pluginHooks.addNoop("postNormalization");
119
+
120
+ // Called with the text before / after creating block elements like code blocks and lists. Note that this is called recursively
121
+ // with inner content, e.g. it's called with the full text, and then only with the content of a blockquote. The inner
122
+ // call will receive outdented text.
123
+ pluginHooks.addNoop("preBlockGamut");
124
+ pluginHooks.addNoop("postBlockGamut");
125
+
126
+ // called with the text of a single block element before / after the span-level conversions (bold, code spans, etc.) have been made
127
+ pluginHooks.addNoop("preSpanGamut");
128
+ pluginHooks.addNoop("postSpanGamut");
129
+
130
+ // called with the final cooked HTML code. The result of this plugin hook is the actual output of makeHtml
131
+ pluginHooks.addNoop("postConversion");
132
+
133
+ //
134
+ // Private state of the converter instance:
135
+ //
136
+
137
+ // Global hashes, used by various utility routines
138
+ var g_urls;
139
+ var g_titles;
140
+ var g_html_blocks;
141
+
142
+ // Used to track when we're inside an ordered or unordered list
143
+ // (see _ProcessListItems() for details):
144
+ var g_list_level;
145
+
146
+ this.makeHtml = function (text) {
147
+
148
+ //
149
+ // Main function. The order in which other subs are called here is
150
+ // essential. Link and image substitutions need to happen before
151
+ // _EscapeSpecialCharsWithinTagAttributes(), so that any *'s or _'s in the <a>
152
+ // and <img> tags get encoded.
153
+ //
154
+
155
+ // This will only happen if makeHtml on the same converter instance is called from a plugin hook.
156
+ // Don't do that.
157
+ if (g_urls)
158
+ throw new Error("Recursive call to converter.makeHtml");
159
+
160
+ // Create the private state objects.
161
+ g_urls = new SaveHash();
162
+ g_titles = new SaveHash();
163
+ g_html_blocks = [];
164
+ g_list_level = 0;
165
+
166
+ text = pluginHooks.preConversion(text);
167
+
168
+ // attacklab: Replace ~ with ~T
169
+ // This lets us use tilde as an escape char to avoid md5 hashes
170
+ // The choice of character is arbitray; anything that isn't
171
+ // magic in Markdown will work.
172
+ text = text.replace(/~/g, "~T");
173
+
174
+ // attacklab: Replace $ with ~D
175
+ // RegExp interprets $ as a special character
176
+ // when it's in a replacement string
177
+ text = text.replace(/\$/g, "~D");
178
+
179
+ // Standardize line endings
180
+ text = text.replace(/\r\n/g, "\n"); // DOS to Unix
181
+ text = text.replace(/\r/g, "\n"); // Mac to Unix
182
+
183
+ // Make sure text begins and ends with a couple of newlines:
184
+ text = "\n\n" + text + "\n\n";
185
+
186
+ // Convert all tabs to spaces.
187
+ text = _Detab(text);
188
+
189
+ // Strip any lines consisting only of spaces and tabs.
190
+ // This makes subsequent regexen easier to write, because we can
191
+ // match consecutive blank lines with /\n+/ instead of something
192
+ // contorted like /[ \t]*\n+/ .
193
+ text = text.replace(/^[ \t]+$/mg, "");
194
+
195
+ text = pluginHooks.postNormalization(text);
196
+
197
+ // Turn block-level HTML blocks into hash entries
198
+ text = _HashHTMLBlocks(text);
199
+
200
+ // Strip link definitions, store in hashes.
201
+ text = _StripLinkDefinitions(text);
202
+
203
+ text = _RunBlockGamut(text);
204
+
205
+ text = _UnescapeSpecialChars(text);
206
+
207
+ // attacklab: Restore dollar signs
208
+ text = text.replace(/~D/g, "$$");
209
+
210
+ // attacklab: Restore tildes
211
+ text = text.replace(/~T/g, "~");
212
+
213
+ text = pluginHooks.postConversion(text);
214
+
215
+ g_html_blocks = g_titles = g_urls = null;
216
+
217
+ return text;
218
+ };
219
+
220
+ function _StripLinkDefinitions(text) {
221
+ //
222
+ // Strips link definitions from text, stores the URLs and titles in
223
+ // hash references.
224
+ //
225
+
226
+ // Link defs are in the form: ^[id]: url "optional title"
227
+
228
+ /*
229
+ text = text.replace(/
230
+ ^[ ]{0,3}\[(.+)\]: // id = $1 attacklab: g_tab_width - 1
231
+ [ \t]*
232
+ \n? // maybe *one* newline
233
+ [ \t]*
234
+ <?(\S+?)>? // url = $2
235
+ (?=\s|$) // lookahead for whitespace instead of the lookbehind removed below
236
+ [ \t]*
237
+ \n? // maybe one newline
238
+ [ \t]*
239
+ ( // (potential) title = $3
240
+ (\n*) // any lines skipped = $4 attacklab: lookbehind removed
241
+ [ \t]+
242
+ ["(]
243
+ (.+?) // title = $5
244
+ [")]
245
+ [ \t]*
246
+ )? // title is optional
247
+ (?:\n+|$)
248
+ /gm, function(){...});
249
+ */
250
+
251
+ text = text.replace(/^[ ]{0,3}\[(.+)\]:[ \t]*\n?[ \t]*<?(\S+?)>?(?=\s|$)[ \t]*\n?[ \t]*((\n*)["(](.+?)[")][ \t]*)?(?:\n+)/gm,
252
+ function (wholeMatch, m1, m2, m3, m4, m5) {
253
+ m1 = m1.toLowerCase();
254
+ g_urls.set(m1, _EncodeAmpsAndAngles(m2)); // Link IDs are case-insensitive
255
+ if (m4) {
256
+ // Oops, found blank lines, so it's not a title.
257
+ // Put back the parenthetical statement we stole.
258
+ return m3;
259
+ } else if (m5) {
260
+ g_titles.set(m1, m5.replace(/"/g, "&quot;"));
261
+ }
262
+
263
+ // Completely remove the definition from the text
264
+ return "";
265
+ }
266
+ );
267
+
268
+ return text;
269
+ }
270
+
271
+ function _HashHTMLBlocks(text) {
272
+
273
+ // Hashify HTML blocks:
274
+ // We only want to do this for block-level HTML tags, such as headers,
275
+ // lists, and tables. That's because we still want to wrap <p>s around
276
+ // "paragraphs" that are wrapped in non-block-level tags, such as anchors,
277
+ // phrase emphasis, and spans. The list of tags we're looking for is
278
+ // hard-coded:
279
+ var block_tags_a = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del"
280
+ var block_tags_b = "p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math"
281
+
282
+ // First, look for nested blocks, e.g.:
283
+ // <div>
284
+ // <div>
285
+ // tags for inner block must be indented.
286
+ // </div>
287
+ // </div>
288
+ //
289
+ // The outermost tags must start at the left margin for this to match, and
290
+ // the inner nested divs must be indented.
291
+ // We need to do this before the next, more liberal match, because the next
292
+ // match will start at the first `<div>` and stop at the first `</div>`.
293
+
294
+ // attacklab: This regex can be expensive when it fails.
295
+
296
+ /*
297
+ text = text.replace(/
298
+ ( // save in $1
299
+ ^ // start of line (with /m)
300
+ <($block_tags_a) // start tag = $2
301
+ \b // word break
302
+ // attacklab: hack around khtml/pcre bug...
303
+ [^\r]*?\n // any number of lines, minimally matching
304
+ </\2> // the matching end tag
305
+ [ \t]* // trailing spaces/tabs
306
+ (?=\n+) // followed by a newline
307
+ ) // attacklab: there are sentinel newlines at end of document
308
+ /gm,function(){...}};
309
+ */
310
+ text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del)\b[^\r]*?\n<\/\2>[ \t]*(?=\n+))/gm, hashElement);
311
+
312
+ //
313
+ // Now match more liberally, simply from `\n<tag>` to `</tag>\n`
314
+ //
315
+
316
+ /*
317
+ text = text.replace(/
318
+ ( // save in $1
319
+ ^ // start of line (with /m)
320
+ <($block_tags_b) // start tag = $2
321
+ \b // word break
322
+ // attacklab: hack around khtml/pcre bug...
323
+ [^\r]*? // any number of lines, minimally matching
324
+ .*</\2> // the matching end tag
325
+ [ \t]* // trailing spaces/tabs
326
+ (?=\n+) // followed by a newline
327
+ ) // attacklab: there are sentinel newlines at end of document
328
+ /gm,function(){...}};
329
+ */
330
+ text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math)\b[^\r]*?.*<\/\2>[ \t]*(?=\n+)\n)/gm, hashElement);
331
+
332
+ // Special case just for <hr />. It was easier to make a special case than
333
+ // to make the other regex more complicated.
334
+
335
+ /*
336
+ text = text.replace(/
337
+ \n // Starting after a blank line
338
+ [ ]{0,3}
339
+ ( // save in $1
340
+ (<(hr) // start tag = $2
341
+ \b // word break
342
+ ([^<>])*?
343
+ \/?>) // the matching end tag
344
+ [ \t]*
345
+ (?=\n{2,}) // followed by a blank line
346
+ )
347
+ /g,hashElement);
348
+ */
349
+ text = text.replace(/\n[ ]{0,3}((<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g, hashElement);
350
+
351
+ // Special case for standalone HTML comments:
352
+
353
+ /*
354
+ text = text.replace(/
355
+ \n\n // Starting after a blank line
356
+ [ ]{0,3} // attacklab: g_tab_width - 1
357
+ ( // save in $1
358
+ <!
359
+ (--(?:|(?:[^>-]|-[^>])(?:[^-]|-[^-])*)--) // see http://www.w3.org/TR/html-markup/syntax.html#comments and http://meta.stackoverflow.com/q/95256
360
+ >
361
+ [ \t]*
362
+ (?=\n{2,}) // followed by a blank line
363
+ )
364
+ /g,hashElement);
365
+ */
366
+ text = text.replace(/\n\n[ ]{0,3}(<!(--(?:|(?:[^>-]|-[^>])(?:[^-]|-[^-])*)--)>[ \t]*(?=\n{2,}))/g, hashElement);
367
+
368
+ // PHP and ASP-style processor instructions (<?...?> and <%...%>)
369
+
370
+ /*
371
+ text = text.replace(/
372
+ (?:
373
+ \n\n // Starting after a blank line
374
+ )
375
+ ( // save in $1
376
+ [ ]{0,3} // attacklab: g_tab_width - 1
377
+ (?:
378
+ <([?%]) // $2
379
+ [^\r]*?
380
+ \2>
381
+ )
382
+ [ \t]*
383
+ (?=\n{2,}) // followed by a blank line
384
+ )
385
+ /g,hashElement);
386
+ */
387
+ text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g, hashElement);
388
+
389
+ return text;
390
+ }
391
+
392
+ function hashElement(wholeMatch, m1) {
393
+ var blockText = m1;
394
+
395
+ // Undo double lines
396
+ blockText = blockText.replace(/^\n+/, "");
397
+
398
+ // strip trailing blank lines
399
+ blockText = blockText.replace(/\n+$/g, "");
400
+
401
+ // Replace the element text with a marker ("~KxK" where x is its key)
402
+ blockText = "\n\n~K" + (g_html_blocks.push(blockText) - 1) + "K\n\n";
403
+
404
+ return blockText;
405
+ }
406
+
407
+ var blockGamutHookCallback = function (t) { return _RunBlockGamut(t); }
408
+
409
+ function _RunBlockGamut(text, doNotUnhash) {
410
+ //
411
+ // These are all the transformations that form block-level
412
+ // tags like paragraphs, headers, and list items.
413
+ //
414
+
415
+ text = pluginHooks.preBlockGamut(text, blockGamutHookCallback);
416
+
417
+ text = _DoHeaders(text);
418
+
419
+ // Do Horizontal Rules:
420
+ var replacement = "<hr />\n";
421
+ text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm, replacement);
422
+ text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ \t]*$/gm, replacement);
423
+ text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm, replacement);
424
+
425
+ text = _DoLists(text);
426
+ text = _DoCodeBlocks(text);
427
+ text = _DoBlockQuotes(text);
428
+
429
+ text = pluginHooks.postBlockGamut(text, blockGamutHookCallback);
430
+
431
+ // We already ran _HashHTMLBlocks() before, in Markdown(), but that
432
+ // was to escape raw HTML in the original Markdown source. This time,
433
+ // we're escaping the markup we've just created, so that we don't wrap
434
+ // <p> tags around block-level tags.
435
+ text = _HashHTMLBlocks(text);
436
+ text = _FormParagraphs(text, doNotUnhash);
437
+
438
+ return text;
439
+ }
440
+
441
+ function _RunSpanGamut(text) {
442
+ //
443
+ // These are all the transformations that occur *within* block-level
444
+ // tags like paragraphs, headers, and list items.
445
+ //
446
+
447
+ text = pluginHooks.preSpanGamut(text);
448
+
449
+ text = _DoCodeSpans(text);
450
+ text = _EscapeSpecialCharsWithinTagAttributes(text);
451
+ text = _EncodeBackslashEscapes(text);
452
+
453
+ // Process anchor and image tags. Images must come first,
454
+ // because ![foo][f] looks like an anchor.
455
+ text = _DoImages(text);
456
+ text = _DoAnchors(text);
457
+
458
+ // Make links out of things like `<http://example.com/>`
459
+ // Must come after _DoAnchors(), because you can use < and >
460
+ // delimiters in inline links like [this](<url>).
461
+ text = _DoAutoLinks(text);
462
+
463
+ text = text.replace(/~P/g, "://"); // put in place to prevent autolinking; reset now
464
+
465
+ text = _EncodeAmpsAndAngles(text);
466
+ text = _DoItalicsAndBold(text);
467
+
468
+ // Do hard breaks:
469
+ text = text.replace(/ +\n/g, " <br>\n");
470
+
471
+ text = pluginHooks.postSpanGamut(text);
472
+
473
+ return text;
474
+ }
475
+
476
+ function _EscapeSpecialCharsWithinTagAttributes(text) {
477
+ //
478
+ // Within tags -- meaning between < and > -- encode [\ ` * _] so they
479
+ // don't conflict with their use in Markdown for code, italics and strong.
480
+ //
481
+
482
+ // Build a regex to find HTML tags and comments. See Friedl's
483
+ // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
484
+
485
+ // SE: changed the comment part of the regex
486
+
487
+ var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|<!(--(?:|(?:[^>-]|-[^>])(?:[^-]|-[^-])*)--)>)/gi;
488
+
489
+ text = text.replace(regex, function (wholeMatch) {
490
+ var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g, "$1`");
491
+ tag = escapeCharacters(tag, wholeMatch.charAt(1) == "!" ? "\\`*_/" : "\\`*_"); // also escape slashes in comments to prevent autolinking there -- http://meta.stackoverflow.com/questions/95987
492
+ return tag;
493
+ });
494
+
495
+ return text;
496
+ }
497
+
498
+ function _DoAnchors(text) {
499
+ //
500
+ // Turn Markdown link shortcuts into XHTML <a> tags.
501
+ //
502
+ //
503
+ // First, handle reference-style links: [link text] [id]
504
+ //
505
+
506
+ /*
507
+ text = text.replace(/
508
+ ( // wrap whole match in $1
509
+ \[
510
+ (
511
+ (?:
512
+ \[[^\]]*\] // allow brackets nested one level
513
+ |
514
+ [^\[] // or anything else
515
+ )*
516
+ )
517
+ \]
518
+
519
+ [ ]? // one optional space
520
+ (?:\n[ ]*)? // one optional newline followed by spaces
521
+
522
+ \[
523
+ (.*?) // id = $3
524
+ \]
525
+ )
526
+ ()()()() // pad remaining backreferences
527
+ /g, writeAnchorTag);
528
+ */
529
+ text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g, writeAnchorTag);
530
+
531
+ //
532
+ // Next, inline-style links: [link text](url "optional title")
533
+ //
534
+
535
+ /*
536
+ text = text.replace(/
537
+ ( // wrap whole match in $1
538
+ \[
539
+ (
540
+ (?:
541
+ \[[^\]]*\] // allow brackets nested one level
542
+ |
543
+ [^\[\]] // or anything else
544
+ )*
545
+ )
546
+ \]
547
+ \( // literal paren
548
+ [ \t]*
549
+ () // no id, so leave $3 empty
550
+ <?( // href = $4
551
+ (?:
552
+ \([^)]*\) // allow one level of (correctly nested) parens (think MSDN)
553
+ |
554
+ [^()\s]
555
+ )*?
556
+ )>?
557
+ [ \t]*
558
+ ( // $5
559
+ (['"]) // quote char = $6
560
+ (.*?) // Title = $7
561
+ \6 // matching quote
562
+ [ \t]* // ignore any spaces/tabs between closing quote and )
563
+ )? // title is optional
564
+ \)
565
+ )
566
+ /g, writeAnchorTag);
567
+ */
568
+
569
+ text = text.replace(/(\[((?:\[[^\]]*\]|[^\[\]])*)\]\([ \t]*()<?((?:\([^)]*\)|[^()\s])*?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g, writeAnchorTag);
570
+
571
+ //
572
+ // Last, handle reference-style shortcuts: [link text]
573
+ // These must come last in case you've also got [link test][1]
574
+ // or [link test](/foo)
575
+ //
576
+
577
+ /*
578
+ text = text.replace(/
579
+ ( // wrap whole match in $1
580
+ \[
581
+ ([^\[\]]+) // link text = $2; can't contain '[' or ']'
582
+ \]
583
+ )
584
+ ()()()()() // pad rest of backreferences
585
+ /g, writeAnchorTag);
586
+ */
587
+ text = text.replace(/(\[([^\[\]]+)\])()()()()()/g, writeAnchorTag);
588
+
589
+ return text;
590
+ }
591
+
592
+ function writeAnchorTag(wholeMatch, m1, m2, m3, m4, m5, m6, m7) {
593
+ if (m7 == undefined) m7 = "";
594
+ var whole_match = m1;
595
+ var link_text = m2.replace(/:\/\//g, "~P"); // to prevent auto-linking withing the link. will be converted back after the auto-linker runs
596
+ var link_id = m3.toLowerCase();
597
+ var url = m4;
598
+ var title = m7;
599
+
600
+ if (url == "") {
601
+ if (link_id == "") {
602
+ // lower-case and turn embedded newlines into spaces
603
+ link_id = link_text.toLowerCase().replace(/ ?\n/g, " ");
604
+ }
605
+ url = "#" + link_id;
606
+
607
+ if (g_urls.get(link_id) != undefined) {
608
+ url = g_urls.get(link_id);
609
+ if (g_titles.get(link_id) != undefined) {
610
+ title = g_titles.get(link_id);
611
+ }
612
+ }
613
+ else {
614
+ if (whole_match.search(/\(\s*\)$/m) > -1) {
615
+ // Special case for explicit empty url
616
+ url = "";
617
+ } else {
618
+ return whole_match;
619
+ }
620
+ }
621
+ }
622
+ url = encodeProblemUrlChars(url);
623
+ url = escapeCharacters(url, "*_");
624
+ var result = "<a href=\"" + url + "\"";
625
+
626
+ if (title != "") {
627
+ title = attributeEncode(title);
628
+ title = escapeCharacters(title, "*_");
629
+ result += " title=\"" + title + "\"";
630
+ }
631
+
632
+ result += ">" + link_text + "</a>";
633
+
634
+ return result;
635
+ }
636
+
637
+ function _DoImages(text) {
638
+ //
639
+ // Turn Markdown image shortcuts into <img> tags.
640
+ //
641
+
642
+ //
643
+ // First, handle reference-style labeled images: ![alt text][id]
644
+ //
645
+
646
+ /*
647
+ text = text.replace(/
648
+ ( // wrap whole match in $1
649
+ !\[
650
+ (.*?) // alt text = $2
651
+ \]
652
+
653
+ [ ]? // one optional space
654
+ (?:\n[ ]*)? // one optional newline followed by spaces
655
+
656
+ \[
657
+ (.*?) // id = $3
658
+ \]
659
+ )
660
+ ()()()() // pad rest of backreferences
661
+ /g, writeImageTag);
662
+ */
663
+ text = text.replace(/(!\[(.*?)\][ ]?(?:\n[ ]*)?\[(.*?)\])()()()()/g, writeImageTag);
664
+
665
+ //
666
+ // Next, handle inline images: ![alt text](url "optional title")
667
+ // Don't forget: encode * and _
668
+
669
+ /*
670
+ text = text.replace(/
671
+ ( // wrap whole match in $1
672
+ !\[
673
+ (.*?) // alt text = $2
674
+ \]
675
+ \s? // One optional whitespace character
676
+ \( // literal paren
677
+ [ \t]*
678
+ () // no id, so leave $3 empty
679
+ <?(\S+?)>? // src url = $4
680
+ [ \t]*
681
+ ( // $5
682
+ (['"]) // quote char = $6
683
+ (.*?) // title = $7
684
+ \6 // matching quote
685
+ [ \t]*
686
+ )? // title is optional
687
+ \)
688
+ )
689
+ /g, writeImageTag);
690
+ */
691
+ text = text.replace(/(!\[(.*?)\]\s?\([ \t]*()<?(\S+?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g, writeImageTag);
692
+
693
+ return text;
694
+ }
695
+
696
+ function attributeEncode(text) {
697
+ // unconditionally replace angle brackets here -- what ends up in an attribute (e.g. alt or title)
698
+ // never makes sense to have verbatim HTML in it (and the sanitizer would totally break it)
699
+ return text.replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
700
+ }
701
+
702
+ function writeImageTag(wholeMatch, m1, m2, m3, m4, m5, m6, m7) {
703
+ var whole_match = m1;
704
+ var alt_text = m2;
705
+ var link_id = m3.toLowerCase();
706
+ var url = m4;
707
+ var title = m7;
708
+
709
+ if (!title) title = "";
710
+
711
+ if (url == "") {
712
+ if (link_id == "") {
713
+ // lower-case and turn embedded newlines into spaces
714
+ link_id = alt_text.toLowerCase().replace(/ ?\n/g, " ");
715
+ }
716
+ url = "#" + link_id;
717
+
718
+ if (g_urls.get(link_id) != undefined) {
719
+ url = g_urls.get(link_id);
720
+ if (g_titles.get(link_id) != undefined) {
721
+ title = g_titles.get(link_id);
722
+ }
723
+ }
724
+ else {
725
+ return whole_match;
726
+ }
727
+ }
728
+
729
+ alt_text = escapeCharacters(attributeEncode(alt_text), "*_[]()");
730
+ url = escapeCharacters(url, "*_");
731
+ var result = "<img src=\"" + url + "\" alt=\"" + alt_text + "\"";
732
+
733
+ // attacklab: Markdown.pl adds empty title attributes to images.
734
+ // Replicate this bug.
735
+
736
+ //if (title != "") {
737
+ title = attributeEncode(title);
738
+ title = escapeCharacters(title, "*_");
739
+ result += " title=\"" + title + "\"";
740
+ //}
741
+
742
+ result += " />";
743
+
744
+ return result;
745
+ }
746
+
747
+ function _DoHeaders(text) {
748
+
749
+ // Setext-style headers:
750
+ // Header 1
751
+ // ========
752
+ //
753
+ // Header 2
754
+ // --------
755
+ //
756
+ text = text.replace(/^(.+)[ \t]*\n=+[ \t]*\n+/gm,
757
+ function (wholeMatch, m1) { return "<h1>" + _RunSpanGamut(m1) + "</h1>\n\n"; }
758
+ );
759
+
760
+ text = text.replace(/^(.+)[ \t]*\n-+[ \t]*\n+/gm,
761
+ function (matchFound, m1) { return "<h2>" + _RunSpanGamut(m1) + "</h2>\n\n"; }
762
+ );
763
+
764
+ // atx-style headers:
765
+ // # Header 1
766
+ // ## Header 2
767
+ // ## Header 2 with closing hashes ##
768
+ // ...
769
+ // ###### Header 6
770
+ //
771
+
772
+ /*
773
+ text = text.replace(/
774
+ ^(\#{1,6}) // $1 = string of #'s
775
+ [ \t]*
776
+ (.+?) // $2 = Header text
777
+ [ \t]*
778
+ \#* // optional closing #'s (not counted)
779
+ \n+
780
+ /gm, function() {...});
781
+ */
782
+
783
+ text = text.replace(/^(\#{1,6})[ \t]*(.+?)[ \t]*\#*\n+/gm,
784
+ function (wholeMatch, m1, m2) {
785
+ var h_level = m1.length;
786
+ return "<h" + h_level + ">" + _RunSpanGamut(m2) + "</h" + h_level + ">\n\n";
787
+ }
788
+ );
789
+
790
+ return text;
791
+ }
792
+
793
+ function _DoLists(text, isInsideParagraphlessListItem) {
794
+ //
795
+ // Form HTML ordered (numbered) and unordered (bulleted) lists.
796
+ //
797
+
798
+ // attacklab: add sentinel to hack around khtml/safari bug:
799
+ // http://bugs.webkit.org/show_bug.cgi?id=11231
800
+ text += "~0";
801
+
802
+ // Re-usable pattern to match any entirel ul or ol list:
803
+
804
+ /*
805
+ var whole_list = /
806
+ ( // $1 = whole list
807
+ ( // $2
808
+ [ ]{0,3} // attacklab: g_tab_width - 1
809
+ ([*+-]|\d+[.]) // $3 = first list item marker
810
+ [ \t]+
811
+ )
812
+ [^\r]+?
813
+ ( // $4
814
+ ~0 // sentinel for workaround; should be $
815
+ |
816
+ \n{2,}
817
+ (?=\S)
818
+ (?! // Negative lookahead for another list item marker
819
+ [ \t]*
820
+ (?:[*+-]|\d+[.])[ \t]+
821
+ )
822
+ )
823
+ )
824
+ /g
825
+ */
826
+ var whole_list = /^(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
827
+
828
+ if (g_list_level) {
829
+ text = text.replace(whole_list, function (wholeMatch, m1, m2) {
830
+ var list = m1;
831
+ var list_type = (m2.search(/[*+-]/g) > -1) ? "ul" : "ol";
832
+
833
+ var result = _ProcessListItems(list, list_type, isInsideParagraphlessListItem);
834
+
835
+ // Trim any trailing whitespace, to put the closing `</$list_type>`
836
+ // up on the preceding line, to get it past the current stupid
837
+ // HTML block parser. This is a hack to work around the terrible
838
+ // hack that is the HTML block parser.
839
+ result = result.replace(/\s+$/, "");
840
+ result = "<" + list_type + ">" + result + "</" + list_type + ">\n";
841
+ return result;
842
+ });
843
+ } else {
844
+ whole_list = /(\n\n|^\n?)(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/g;
845
+ text = text.replace(whole_list, function (wholeMatch, m1, m2, m3) {
846
+ var runup = m1;
847
+ var list = m2;
848
+
849
+ var list_type = (m3.search(/[*+-]/g) > -1) ? "ul" : "ol";
850
+ var result = _ProcessListItems(list, list_type);
851
+ result = runup + "<" + list_type + ">\n" + result + "</" + list_type + ">\n";
852
+ return result;
853
+ });
854
+ }
855
+
856
+ // attacklab: strip sentinel
857
+ text = text.replace(/~0/, "");
858
+
859
+ return text;
860
+ }
861
+
862
+ var _listItemMarkers = { ol: "\\d+[.]", ul: "[*+-]" };
863
+
864
+ function _ProcessListItems(list_str, list_type, isInsideParagraphlessListItem) {
865
+ //
866
+ // Process the contents of a single ordered or unordered list, splitting it
867
+ // into individual list items.
868
+ //
869
+ // list_type is either "ul" or "ol".
870
+
871
+ // The $g_list_level global keeps track of when we're inside a list.
872
+ // Each time we enter a list, we increment it; when we leave a list,
873
+ // we decrement. If it's zero, we're not in a list anymore.
874
+ //
875
+ // We do this because when we're not inside a list, we want to treat
876
+ // something like this:
877
+ //
878
+ // I recommend upgrading to version
879
+ // 8. Oops, now this line is treated
880
+ // as a sub-list.
881
+ //
882
+ // As a single paragraph, despite the fact that the second line starts
883
+ // with a digit-period-space sequence.
884
+ //
885
+ // Whereas when we're inside a list (or sub-list), that line will be
886
+ // treated as the start of a sub-list. What a kludge, huh? This is
887
+ // an aspect of Markdown's syntax that's hard to parse perfectly
888
+ // without resorting to mind-reading. Perhaps the solution is to
889
+ // change the syntax rules such that sub-lists must start with a
890
+ // starting cardinal number; e.g. "1." or "a.".
891
+
892
+ g_list_level++;
893
+
894
+ // trim trailing blank lines:
895
+ list_str = list_str.replace(/\n{2,}$/, "\n");
896
+
897
+ // attacklab: add sentinel to emulate \z
898
+ list_str += "~0";
899
+
900
+ // In the original attacklab showdown, list_type was not given to this function, and anything
901
+ // that matched /[*+-]|\d+[.]/ would just create the next <li>, causing this mismatch:
902
+ //
903
+ // Markdown rendered by WMD rendered by MarkdownSharp
904
+ // ------------------------------------------------------------------
905
+ // 1. first 1. first 1. first
906
+ // 2. second 2. second 2. second
907
+ // - third 3. third * third
908
+ //
909
+ // We changed this to behave identical to MarkdownSharp. This is the constructed RegEx,
910
+ // with {MARKER} being one of \d+[.] or [*+-], depending on list_type:
911
+
912
+ /*
913
+ list_str = list_str.replace(/
914
+ (^[ \t]*) // leading whitespace = $1
915
+ ({MARKER}) [ \t]+ // list marker = $2
916
+ ([^\r]+? // list item text = $3
917
+ (\n+)
918
+ )
919
+ (?=
920
+ (~0 | \2 ({MARKER}) [ \t]+)
921
+ )
922
+ /gm, function(){...});
923
+ */
924
+
925
+ var marker = _listItemMarkers[list_type];
926
+ var re = new RegExp("(^[ \\t]*)(" + marker + ")[ \\t]+([^\\r]+?(\\n+))(?=(~0|\\1(" + marker + ")[ \\t]+))", "gm");
927
+ var last_item_had_a_double_newline = false;
928
+ list_str = list_str.replace(re,
929
+ function (wholeMatch, m1, m2, m3) {
930
+ var item = m3;
931
+ var leading_space = m1;
932
+ var ends_with_double_newline = /\n\n$/.test(item);
933
+ var contains_double_newline = ends_with_double_newline || item.search(/\n{2,}/) > -1;
934
+
935
+ if (contains_double_newline || last_item_had_a_double_newline) {
936
+ item = _RunBlockGamut(_Outdent(item), /* doNotUnhash = */true);
937
+ }
938
+ else {
939
+ // Recursion for sub-lists:
940
+ item = _DoLists(_Outdent(item), /* isInsideParagraphlessListItem= */ true);
941
+ item = item.replace(/\n$/, ""); // chomp(item)
942
+ if (!isInsideParagraphlessListItem) // only the outer-most item should run this, otherwise it's run multiple times for the inner ones
943
+ item = _RunSpanGamut(item);
944
+ }
945
+ last_item_had_a_double_newline = ends_with_double_newline;
946
+ return "<li>" + item + "</li>\n";
947
+ }
948
+ );
949
+
950
+ // attacklab: strip sentinel
951
+ list_str = list_str.replace(/~0/g, "");
952
+
953
+ g_list_level--;
954
+ return list_str;
955
+ }
956
+
957
+ function _DoCodeBlocks(text) {
958
+ //
959
+ // Process Markdown `<pre><code>` blocks.
960
+ //
961
+
962
+ /*
963
+ text = text.replace(/
964
+ (?:\n\n|^)
965
+ ( // $1 = the code block -- one or more lines, starting with a space/tab
966
+ (?:
967
+ (?:[ ]{4}|\t) // Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
968
+ .*\n+
969
+ )+
970
+ )
971
+ (\n*[ ]{0,3}[^ \t\n]|(?=~0)) // attacklab: g_tab_width
972
+ /g ,function(){...});
973
+ */
974
+
975
+ // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
976
+ text += "~0";
977
+
978
+ text = text.replace(/(?:\n\n|^\n?)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g,
979
+ function (wholeMatch, m1, m2) {
980
+ var codeblock = m1;
981
+ var nextChar = m2;
982
+
983
+ codeblock = _EncodeCode(_Outdent(codeblock));
984
+ codeblock = _Detab(codeblock);
985
+ codeblock = codeblock.replace(/^\n+/g, ""); // trim leading newlines
986
+ codeblock = codeblock.replace(/\n+$/g, ""); // trim trailing whitespace
987
+
988
+ codeblock = "<pre><code>" + codeblock + "\n</code></pre>";
989
+
990
+ return "\n\n" + codeblock + "\n\n" + nextChar;
991
+ }
992
+ );
993
+
994
+ // attacklab: strip sentinel
995
+ text = text.replace(/~0/, "");
996
+
997
+ return text;
998
+ }
999
+
1000
+ function hashBlock(text) {
1001
+ text = text.replace(/(^\n+|\n+$)/g, "");
1002
+ return "\n\n~K" + (g_html_blocks.push(text) - 1) + "K\n\n";
1003
+ }
1004
+
1005
+ function _DoCodeSpans(text) {
1006
+ //
1007
+ // * Backtick quotes are used for <code></code> spans.
1008
+ //
1009
+ // * You can use multiple backticks as the delimiters if you want to
1010
+ // include literal backticks in the code span. So, this input:
1011
+ //
1012
+ // Just type ``foo `bar` baz`` at the prompt.
1013
+ //
1014
+ // Will translate to:
1015
+ //
1016
+ // <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
1017
+ //
1018
+ // There's no arbitrary limit to the number of backticks you
1019
+ // can use as delimters. If you need three consecutive backticks
1020
+ // in your code, use four for delimiters, etc.
1021
+ //
1022
+ // * You can use spaces to get literal backticks at the edges:
1023
+ //
1024
+ // ... type `` `bar` `` ...
1025
+ //
1026
+ // Turns to:
1027
+ //
1028
+ // ... type <code>`bar`</code> ...
1029
+ //
1030
+
1031
+ /*
1032
+ text = text.replace(/
1033
+ (^|[^\\]) // Character before opening ` can't be a backslash
1034
+ (`+) // $2 = Opening run of `
1035
+ ( // $3 = The code block
1036
+ [^\r]*?
1037
+ [^`] // attacklab: work around lack of lookbehind
1038
+ )
1039
+ \2 // Matching closer
1040
+ (?!`)
1041
+ /gm, function(){...});
1042
+ */
1043
+
1044
+ text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
1045
+ function (wholeMatch, m1, m2, m3, m4) {
1046
+ var c = m3;
1047
+ c = c.replace(/^([ \t]*)/g, ""); // leading whitespace
1048
+ c = c.replace(/[ \t]*$/g, ""); // trailing whitespace
1049
+ c = _EncodeCode(c);
1050
+ c = c.replace(/:\/\//g, "~P"); // to prevent auto-linking. Not necessary in code *blocks*, but in code spans. Will be converted back after the auto-linker runs.
1051
+ return m1 + "<code>" + c + "</code>";
1052
+ }
1053
+ );
1054
+
1055
+ return text;
1056
+ }
1057
+
1058
+ function _EncodeCode(text) {
1059
+ //
1060
+ // Encode/escape certain characters inside Markdown code runs.
1061
+ // The point is that in code, these characters are literals,
1062
+ // and lose their special Markdown meanings.
1063
+ //
1064
+ // Encode all ampersands; HTML entities are not
1065
+ // entities within a Markdown code span.
1066
+ text = text.replace(/&/g, "&amp;");
1067
+
1068
+ // Do the angle bracket song and dance:
1069
+ text = text.replace(/</g, "&lt;");
1070
+ text = text.replace(/>/g, "&gt;");
1071
+
1072
+ // Now, escape characters that are magic in Markdown:
1073
+ text = escapeCharacters(text, "\*_{}[]\\", false);
1074
+
1075
+ // jj the line above breaks this:
1076
+ //---
1077
+
1078
+ //* Item
1079
+
1080
+ // 1. Subitem
1081
+
1082
+ // special char: *
1083
+ //---
1084
+
1085
+ return text;
1086
+ }
1087
+
1088
+ function _DoItalicsAndBold(text) {
1089
+
1090
+ // <strong> must go first:
1091
+ text = text.replace(/([\W_]|^)(\*\*|__)(?=\S)([^\r]*?\S[\*_]*)\2([\W_]|$)/g,
1092
+ "$1<strong>$3</strong>$4");
1093
+
1094
+ text = text.replace(/([\W_]|^)(\*|_)(?=\S)([^\r\*_]*?\S)\2([\W_]|$)/g,
1095
+ "$1<em>$3</em>$4");
1096
+
1097
+ return text;
1098
+ }
1099
+
1100
+ function _DoBlockQuotes(text) {
1101
+
1102
+ /*
1103
+ text = text.replace(/
1104
+ ( // Wrap whole match in $1
1105
+ (
1106
+ ^[ \t]*>[ \t]? // '>' at the start of a line
1107
+ .+\n // rest of the first line
1108
+ (.+\n)* // subsequent consecutive lines
1109
+ \n* // blanks
1110
+ )+
1111
+ )
1112
+ /gm, function(){...});
1113
+ */
1114
+
1115
+ text = text.replace(/((^[ \t]*>[ \t]?.+\n(.+\n)*\n*)+)/gm,
1116
+ function (wholeMatch, m1) {
1117
+ var bq = m1;
1118
+
1119
+ // attacklab: hack around Konqueror 3.5.4 bug:
1120
+ // "----------bug".replace(/^-/g,"") == "bug"
1121
+
1122
+ bq = bq.replace(/^[ \t]*>[ \t]?/gm, "~0"); // trim one level of quoting
1123
+
1124
+ // attacklab: clean up hack
1125
+ bq = bq.replace(/~0/g, "");
1126
+
1127
+ bq = bq.replace(/^[ \t]+$/gm, ""); // trim whitespace-only lines
1128
+ bq = _RunBlockGamut(bq); // recurse
1129
+
1130
+ bq = bq.replace(/(^|\n)/g, "$1 ");
1131
+ // These leading spaces screw with <pre> content, so we need to fix that:
1132
+ bq = bq.replace(
1133
+ /(\s*<pre>[^\r]+?<\/pre>)/gm,
1134
+ function (wholeMatch, m1) {
1135
+ var pre = m1;
1136
+ // attacklab: hack around Konqueror 3.5.4 bug:
1137
+ pre = pre.replace(/^ /mg, "~0");
1138
+ pre = pre.replace(/~0/g, "");
1139
+ return pre;
1140
+ });
1141
+
1142
+ return hashBlock("<blockquote>\n" + bq + "\n</blockquote>");
1143
+ }
1144
+ );
1145
+ return text;
1146
+ }
1147
+
1148
+ function _FormParagraphs(text, doNotUnhash) {
1149
+ //
1150
+ // Params:
1151
+ // $text - string to process with html <p> tags
1152
+ //
1153
+
1154
+ // Strip leading and trailing lines:
1155
+ text = text.replace(/^\n+/g, "");
1156
+ text = text.replace(/\n+$/g, "");
1157
+
1158
+ var grafs = text.split(/\n{2,}/g);
1159
+ var grafsOut = [];
1160
+
1161
+ var markerRe = /~K(\d+)K/;
1162
+
1163
+ //
1164
+ // Wrap <p> tags.
1165
+ //
1166
+ var end = grafs.length;
1167
+ for (var i = 0; i < end; i++) {
1168
+ var str = grafs[i];
1169
+
1170
+ // if this is an HTML marker, copy it
1171
+ if (markerRe.test(str)) {
1172
+ grafsOut.push(str);
1173
+ }
1174
+ else if (/\S/.test(str)) {
1175
+ str = _RunSpanGamut(str);
1176
+ str = str.replace(/^([ \t]*)/g, "<p>");
1177
+ str += "</p>"
1178
+ grafsOut.push(str);
1179
+ }
1180
+
1181
+ }
1182
+ //
1183
+ // Unhashify HTML blocks
1184
+ //
1185
+ if (!doNotUnhash) {
1186
+ end = grafsOut.length;
1187
+ for (var i = 0; i < end; i++) {
1188
+ var foundAny = true;
1189
+ while (foundAny) { // we may need several runs, since the data may be nested
1190
+ foundAny = false;
1191
+ grafsOut[i] = grafsOut[i].replace(/~K(\d+)K/g, function (wholeMatch, id) {
1192
+ foundAny = true;
1193
+ return g_html_blocks[id];
1194
+ });
1195
+ }
1196
+ }
1197
+ }
1198
+ return grafsOut.join("\n\n");
1199
+ }
1200
+
1201
+ function _EncodeAmpsAndAngles(text) {
1202
+ // Smart processing for ampersands and angle brackets that need to be encoded.
1203
+
1204
+ // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
1205
+ // http://bumppo.net/projects/amputator/
1206
+ text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, "&amp;");
1207
+
1208
+ // Encode naked <'s
1209
+ text = text.replace(/<(?![a-z\/?!]|~D)/gi, "&lt;");
1210
+
1211
+ return text;
1212
+ }
1213
+
1214
+ function _EncodeBackslashEscapes(text) {
1215
+ //
1216
+ // Parameter: String.
1217
+ // Returns: The string, with after processing the following backslash
1218
+ // escape sequences.
1219
+ //
1220
+
1221
+ // attacklab: The polite way to do this is with the new
1222
+ // escapeCharacters() function:
1223
+ //
1224
+ // text = escapeCharacters(text,"\\",true);
1225
+ // text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
1226
+ //
1227
+ // ...but we're sidestepping its use of the (slow) RegExp constructor
1228
+ // as an optimization for Firefox. This function gets called a LOT.
1229
+
1230
+ text = text.replace(/\\(\\)/g, escapeCharacters_callback);
1231
+ text = text.replace(/\\([`*_{}\[\]()>#+-.!])/g, escapeCharacters_callback);
1232
+ return text;
1233
+ }
1234
+
1235
+ var charInsideUrl = "[-A-Z0-9+&@#/%?=~_|[\\]()!:,.;]",
1236
+ charEndingUrl = "[-A-Z0-9+&@#/%=~_|[\\])]",
1237
+ autoLinkRegex = new RegExp("(=\"|<)?\\b(https?|ftp)(://" + charInsideUrl + "*" + charEndingUrl + ")(?=$|\\W)", "gi"),
1238
+ endCharRegex = new RegExp(charEndingUrl, "i");
1239
+
1240
+ function handleTrailingParens(wholeMatch, lookbehind, protocol, link) {
1241
+ if (lookbehind)
1242
+ return wholeMatch;
1243
+ if (link.charAt(link.length - 1) !== ")")
1244
+ return "<" + protocol + link + ">";
1245
+ var parens = link.match(/[()]/g);
1246
+ var level = 0;
1247
+ for (var i = 0; i < parens.length; i++) {
1248
+ if (parens[i] === "(") {
1249
+ if (level <= 0)
1250
+ level = 1;
1251
+ else
1252
+ level++;
1253
+ }
1254
+ else {
1255
+ level--;
1256
+ }
1257
+ }
1258
+ var tail = "";
1259
+ if (level < 0) {
1260
+ var re = new RegExp("\\){1," + (-level) + "}$");
1261
+ link = link.replace(re, function (trailingParens) {
1262
+ tail = trailingParens;
1263
+ return "";
1264
+ });
1265
+ }
1266
+ if (tail) {
1267
+ var lastChar = link.charAt(link.length - 1);
1268
+ if (!endCharRegex.test(lastChar)) {
1269
+ tail = lastChar + tail;
1270
+ link = link.substr(0, link.length - 1);
1271
+ }
1272
+ }
1273
+ return "<" + protocol + link + ">" + tail;
1274
+ }
1275
+
1276
+ function _DoAutoLinks(text) {
1277
+
1278
+ // note that at this point, all other URL in the text are already hyperlinked as <a href=""></a>
1279
+ // *except* for the <http://www.foo.com> case
1280
+
1281
+ // automatically add < and > around unadorned raw hyperlinks
1282
+ // must be preceded by a non-word character (and not by =" or <) and followed by non-word/EOF character
1283
+ // simulating the lookbehind in a consuming way is okay here, since a URL can neither and with a " nor
1284
+ // with a <, so there is no risk of overlapping matches.
1285
+ text = text.replace(autoLinkRegex, handleTrailingParens);
1286
+
1287
+ // autolink anything like <http://example.com>
1288
+
1289
+ var replacer = function (wholematch, m1) { return "<a href=\"" + m1 + "\">" + pluginHooks.plainLinkText(m1) + "</a>"; }
1290
+ text = text.replace(/<((https?|ftp):[^'">\s]+)>/gi, replacer);
1291
+
1292
+ // Email addresses: <address@domain.foo>
1293
+ /*
1294
+ text = text.replace(/
1295
+ <
1296
+ (?:mailto:)?
1297
+ (
1298
+ [-.\w]+
1299
+ \@
1300
+ [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
1301
+ )
1302
+ >
1303
+ /gi, _DoAutoLinks_callback());
1304
+ */
1305
+
1306
+ /* disabling email autolinking, since we don't do that on the server, either
1307
+ text = text.replace(/<(?:mailto:)?([-.\w]+\@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
1308
+ function(wholeMatch,m1) {
1309
+ return _EncodeEmailAddress( _UnescapeSpecialChars(m1) );
1310
+ }
1311
+ );
1312
+ */
1313
+ return text;
1314
+ }
1315
+
1316
+ function _UnescapeSpecialChars(text) {
1317
+ //
1318
+ // Swap back in all the special characters we've hidden.
1319
+ //
1320
+ text = text.replace(/~E(\d+)E/g,
1321
+ function (wholeMatch, m1) {
1322
+ var charCodeToReplace = parseInt(m1);
1323
+ return String.fromCharCode(charCodeToReplace);
1324
+ }
1325
+ );
1326
+ return text;
1327
+ }
1328
+
1329
+ function _Outdent(text) {
1330
+ //
1331
+ // Remove one level of line-leading tabs or spaces
1332
+ //
1333
+
1334
+ // attacklab: hack around Konqueror 3.5.4 bug:
1335
+ // "----------bug".replace(/^-/g,"") == "bug"
1336
+
1337
+ text = text.replace(/^(\t|[ ]{1,4})/gm, "~0"); // attacklab: g_tab_width
1338
+
1339
+ // attacklab: clean up hack
1340
+ text = text.replace(/~0/g, "")
1341
+
1342
+ return text;
1343
+ }
1344
+
1345
+ function _Detab(text) {
1346
+ if (!/\t/.test(text))
1347
+ return text;
1348
+
1349
+ var spaces = [" ", " ", " ", " "],
1350
+ skew = 0,
1351
+ v;
1352
+
1353
+ return text.replace(/[\n\t]/g, function (match, offset) {
1354
+ if (match === "\n") {
1355
+ skew = offset + 1;
1356
+ return match;
1357
+ }
1358
+ v = (offset - skew) % 4;
1359
+ skew = offset + 1;
1360
+ return spaces[v];
1361
+ });
1362
+ }
1363
+
1364
+ //
1365
+ // attacklab: Utility functions
1366
+ //
1367
+
1368
+ var _problemUrlChars = /(?:["'*()[\]:]|~D)/g;
1369
+
1370
+ // hex-encodes some unusual "problem" chars in URLs to avoid URL detection problems
1371
+ function encodeProblemUrlChars(url) {
1372
+ if (!url)
1373
+ return "";
1374
+
1375
+ var len = url.length;
1376
+
1377
+ return url.replace(_problemUrlChars, function (match, offset) {
1378
+ if (match == "~D") // escape for dollar
1379
+ return "%24";
1380
+ if (match == ":") {
1381
+ if (offset == len - 1 || /[0-9\/]/.test(url.charAt(offset + 1)))
1382
+ return ":"
1383
+ }
1384
+ return "%" + match.charCodeAt(0).toString(16);
1385
+ });
1386
+ }
1387
+
1388
+
1389
+ function escapeCharacters(text, charsToEscape, afterBackslash) {
1390
+ // First we have to escape the escape characters so that
1391
+ // we can build a character class out of them
1392
+ var regexString = "([" + charsToEscape.replace(/([\[\]\\])/g, "\\$1") + "])";
1393
+
1394
+ if (afterBackslash) {
1395
+ regexString = "\\\\" + regexString;
1396
+ }
1397
+
1398
+ var regex = new RegExp(regexString, "g");
1399
+ text = text.replace(regex, escapeCharacters_callback);
1400
+
1401
+ return text;
1402
+ }
1403
+
1404
+
1405
+ function escapeCharacters_callback(wholeMatch, m1) {
1406
+ var charCodeToEscape = m1.charCodeAt(0);
1407
+ return "~E" + charCodeToEscape + "E";
1408
+ }
1409
+
1410
+ }; // end of the Markdown.Converter constructor
1411
+
1412
+ })();