├── images
    └── arrowright.png
├── screenshots
    ├── list.png
    └── detail.png
├── app.wxss
├── pages
    ├── index
    │   ├── index.wxml
    │   ├── header.wxml
    │   ├── list.wxml
    │   ├── index.wxss
    │   └── index.js
    └── detail
    │   ├── index.wxml
    │   ├── index.wxss
    │   └── index.js
├── README.md
├── app.js
├── app.json
├── util
    ├── util.js
    └── marked.min.js
└── wxParse
    ├── wxParse.js
    ├── wxParse.wxss
    ├── html2json.js
    ├── wxDiscode.js
    ├── htmlparser.js
    ├── wxParse.wxml
    └── showdown.js


/images/arrowright.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eyasliu/wechat-app-github-blog/HEAD/images/arrowright.png


--------------------------------------------------------------------------------
/screenshots/list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eyasliu/wechat-app-github-blog/HEAD/screenshots/list.png


--------------------------------------------------------------------------------
/screenshots/detail.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eyasliu/wechat-app-github-blog/HEAD/screenshots/detail.png


--------------------------------------------------------------------------------
/app.wxss:
--------------------------------------------------------------------------------
1 | /**app.wxss**/
2 | .container {
3 |   min-height: 100%;
4 |   font-family: "microsoft yahei";
5 |   background: #f2f2f2;
6 | }
7 | 


--------------------------------------------------------------------------------
/pages/index/index.wxml:
--------------------------------------------------------------------------------
1 | <!--index.wxml-->
2 | <import src="header.wxml" />
3 | <import src="list.wxml" />
4 | 
5 | <scroll-view scroll-y="{{true}}" class="container">
6 | 	<template is="header" data="{{site: site}}" />
7 |   <template is="list" data="{{list: list}}" />
8 | </scroll-view>
9 | 


--------------------------------------------------------------------------------
/pages/index/header.wxml:
--------------------------------------------------------------------------------
 1 | <!-- header -->
 2 | <template name="header">
 3 | 	<view class="header">
 4 | 		<view class="text">
 5 | 			<view class="title">{{site.title}}</view>
 6 | 		</view>
 7 | 		<view class="logo">
 8 | 			<image src="http://image.youzhan.org/e/35/22ccaf4c24ef690f7767e6a3ba5f0.png" />
 9 | 		</view>
10 | 	</view>
11 | </template>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 微信小程序： 展示github博客文章
 2 | 
 3 |  - 博客原文： https://github.com/eyasliu/blog/issues
 4 |  - 博客原地址：http://eyasweb.com
 5 | 
 6 | 本小程序用户展示github的issues文章，可以在 app.json 配置文件中修改你自己的源
 7 | 
 8 | # 截图
 9 | 
10 | **列表**
11 | 
12 | ![](./screenshots/list.png)
13 | 
14 | **详情页**
15 | 
16 | ![](./screenshots/detail.png)
17 | 
18 | # TODO
19 | 
20 |  - 加载下一页


--------------------------------------------------------------------------------
/app.js:
--------------------------------------------------------------------------------
 1 | var config = __wxConfig.config;
 2 | 
 3 | //app.js
 4 | App({
 5 |   onLaunch: function () {
 6 | 
 7 |   },
 8 |   globalData:{
 9 |     config: {
10 |       apiUrl: config.server + '/repos/' + config.github.user + '/' + config.github.repo,
11 |       repoUrl: 'http://github.com/' + config.github.user + '/' + config.github.repo,
12 |       github: config.github
13 |     },
14 |     site: {
15 |       title: 'Eyas'
16 |     }
17 |   }
18 | })
19 | 


--------------------------------------------------------------------------------
/app.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "pages":[
 3 |     "pages/index/index",
 4 |     "pages/detail/index"
 5 |   ],
 6 |   "window":{
 7 |     "backgroundTextStyle":"light",
 8 |     "navigationBarBackgroundColor": "#f2f2f2",
 9 |     "navigationBarTitleText": "Eyas 博客",
10 |     "navigationBarTextStyle":"black"
11 |   },
12 |   "config": {
13 |   	"server": "https://api.github.com",
14 |   	"github": {
15 |   		"user": "eyasliu",
16 |   		"repo": "blog"
17 |   	}
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/pages/index/list.wxml:
--------------------------------------------------------------------------------
 1 | <template name="item">
 2 | 	<view class="item" bindtap="gotoDetail" data-itemid="{{item.number}}">
 3 | 		<view class="item-info">
 4 | 			<view class="item-title">
 5 | 				{{item.title}}
 6 | 			</view>
 7 | 			<view class="item-desc">
 8 | 				{{item.summary}}
 9 | 			</view>
10 | 		</view>
11 | 	</view>
12 | </template>
13 | 
14 | <template name="list">
15 | 	<view class="list" wx:if="{{list.length > 0}}">
16 | 		<template wx:for="{{list}}" wx:key="number" is="item" data="{{item: item}}" />
17 | 	</view>
18 | 	<loading wx:else>加载中...</loading>
19 | </template>


--------------------------------------------------------------------------------
/pages/detail/index.wxml:
--------------------------------------------------------------------------------
 1 | <import src="../../wxParse/wxParse.wxml" />
 2 | <template name="header">
 3 | 	<view class="header">
 4 | 		<navigator url="/pages/index/index" redirect="true">
 5 | 			<image src="/images/arrowright.png" />
 6 | 			返回
 7 | 		</navigator>
 8 | 		<view class="header-title">文章内容</view>
 9 | 	</view>
10 | </template>
11 | 
12 | <view class="detail">
13 | 	<template is="header" data="{{item: item}}" />
14 | 	<view class="content">
15 | 		<view class="title">
16 | 			{{item.title}}
17 | 		</view>
18 | 		<view class="content">
19 | 			<template is="wxParse" data="{{wxParseData}}" />
20 | 		</view>
21 | 	</view>
22 | </view>


--------------------------------------------------------------------------------
/util/util.js:
--------------------------------------------------------------------------------
 1 | var marked = require('./marked.min.js');
 2 | 
 3 | // // markdown parser
 4 | marked.setOptions({
 5 | 	// renderer: new marked.Renderer(),
 6 |   gfm: true,
 7 |   tables: true,
 8 |   breaks: false,
 9 |   pedantic: false,
10 |   sanitize: false,
11 |   smartLists: true,
12 |   smartypants: true
13 | })
14 | // 
15 | // function marked(str){return str}
16 | 
17 | var cutStr = function(str, length){
18 | 	if(!str) return '';
19 | 	return str.substr(0, length);
20 | }
21 | 
22 | var summary = function(markPlain, length){
23 | 	return marked(cutStr.apply(undefined, arguments));
24 | }
25 | 
26 | module.exports = {
27 | 	marked: marked,
28 | 	cutStr: cutStr,
29 | 	summary: summary
30 | }


--------------------------------------------------------------------------------
/pages/detail/index.wxss:
--------------------------------------------------------------------------------
 1 | @import '../../wxParse/wxParse.wxss'
 2 | .detail{
 3 | 	background: #fff;
 4 | 	min-height: 100%;
 5 | 	font-size: 14px;
 6 | 	font-family: "microsoft yahei";
 7 | }
 8 | .header{
 9 | 	background: #fff;
10 | 	height: 2rem;
11 | 	line-height: 2rem;
12 | 	white-space: nowrap;
13 | 	display: flex;
14 | 	border-bottom: 1px solid #eee;
15 | }
16 | .header navigator{
17 | 	display: inline-block;
18 | 	white-space: nowrap;
19 | 	vertical-align: middle;
20 | 	padding-right: 5px;
21 | 	position: absolute;
22 | }
23 | .header navigator image{
24 | 	width: 20px;
25 | 	height: 20px;
26 | 	transform: rotate(180deg);
27 | 	padding-bottom: 8px;
28 | 	padding-right: 8px;
29 | 	display: inline-block;
30 | 	float: left;
31 | }
32 | .header-title{
33 | 	text-align: center;
34 | 	width: 100%;
35 | }
36 | 
37 | .title{
38 | 	font-size: 1.3rem;
39 | 	line-height: 1.3rem;
40 | 	padding: 20rpx 0 30rpx 0;
41 | 	text-align: center;
42 | }
43 | .content{
44 | 	padding: 10rpx;
45 | 	white-space: pre-line;
46 | }


--------------------------------------------------------------------------------
/pages/detail/index.js:
--------------------------------------------------------------------------------
 1 | var WxParse = require('../../wxParse/wxParse.js');
 2 | var app = getApp();
 3 | var config = app.globalData.config;
 4 | Page({
 5 | 	data: {
 6 | 		id: 0,
 7 | 		item: null,
 8 | 		wxParseData: ''
 9 | 	},
10 | 	fetchDetail(id){
11 | 		return new Promise(function(resolve, reject){
12 | 			wx.request({
13 | 				url: config.apiUrl + '/issues/' + id,
14 | 				success: function(res){
15 | 					resolve(res.data);
16 | 				},
17 | 				fail: function(err){
18 | 					reject(err);
19 | 				}
20 | 			})
21 | 		}) 
22 | 	},
23 | 	onReady: function(){
24 | 		wx.setNavigationBarTitle({
25 | 			title: this.data.item.title
26 | 		})
27 | 
28 | 	},
29 | 	onLoad: function(){
30 | 		var data = app.globalData.detailData;
31 | 		var that = this;
32 | 		data.wxParseData = WxParse('html', data.item.body)
33 | 		if(data && data.id){
34 | 			this.setData(data)
35 | 			if(!data.item){
36 | 				fetchDetail(data.id)
37 | 				.then(function(data){
38 | 					// wxParseData = WxParse('html', data.body)
39 | 					// console.log(wxParseData, data)
40 | 					that.setData({
41 | 						item: data,
42 | 						wxParseData
43 | 					})
44 | 				})
45 | 			}
46 | 		}
47 | 	}
48 | })


--------------------------------------------------------------------------------
/wxParse/wxParse.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * author: Di (微信小程序开发工程师)
 3 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
 4 |  *               垂直微信小程序开发交流社区
 5 |  * 
 6 |  * github地址: https://github.com/icindy/wxParse
 7 |  * 
 8 |  * for: 微信小程序富文本解析
 9 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
10 |  */
11 | 
12 | 
13 | var showdown = require('showdown.js');
14 | var HtmlToJson = require('html2json.js');
15 | var wxDiscode = require('wxDiscode.js');
16 | //type 'json','html','markdown'/'md'
17 | 
18 | function wxParse(type,data){
19 |   var wxParseData = [];
20 |   if(type == 'json'){
21 |     var json = HtmlToJson(html);
22 | 	  console.log(JSON.stringify(json, ' ', ' '));
23 |     wxParseData = json.child;
24 |   }else if(type == 'html'){
25 |     data = wxDiscode.strDiscode(data);
26 |     var json = HtmlToJson(data);
27 | 	  // console.log(JSON.stringify(json, ' ', ' '));
28 |     wxParseData = json.child;
29 |   }else if(type == 'md' || type == 'markdown'){
30 |     var converter = new showdown.Converter();
31 |     var html      = converter.makeHtml(data);
32 |     html = wxDiscode.strDiscode(html);
33 |     var json = HtmlToJson(html);
34 | 	  console.log(JSON.stringify(json, ' ', ' '));
35 |     wxParseData = json.child;
36 |   }
37 | 
38 |   return wxParseData;
39 | }
40 | module.exports = wxParse;
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/pages/index/index.wxss:
--------------------------------------------------------------------------------
 1 | /**index.wxss**/
 2 | .userinfo {
 3 |   display: flex;
 4 |   flex-direction: column;
 5 |   align-items: center;
 6 | }
 7 | .header{
 8 |   background: #222;
 9 |   background-repeat: no-repeat;
10 |   background-position: center 0;
11 |   background-size: cover;
12 |   background-image: url("http://static.bootcss.com/expo/img/d/dd/2de797545de56274f03a5920eb3a1.jpg");
13 |   padding: 250rpx 0 0;
14 |   text-align: center;
15 |   min-height: 500rpx;
16 |   position: relative;
17 |   box-sizing: border-box;
18 |   margin-bottom: 30px;
19 |   color: #fff;
20 |   font-size: 2rem;
21 | }
22 | .logo{
23 | 	position: absolute;
24 |   left: 1%;
25 |   right: 1%;
26 |   bottom: -28px;
27 | }
28 | .logo image{
29 | 	width: 50px;
30 | 	height: 45px;
31 | }
32 | .list{
33 | 	padding: 20rpx;
34 | }
35 | .item{
36 | 	text-align: center;
37 | 	background: #fff;
38 | 	margin-bottom: 20rpx;
39 |   padding:20rpx;
40 |   color: #666;
41 |   font-size: 30rpx;
42 | }
43 | 
44 | .item .thumb{
45 | 	height: 0;
46 |   padding-bottom: 70%;
47 |   overflow: hidden;
48 |   cursor: pointer;
49 | }
50 | .item .thumb .image{
51 | 	display: block;
52 |   background-repeat: no-repeat;
53 |   background-position: left 0;
54 |   background-size: 100%;
55 |   width: 100%;
56 |   height: 1000px;
57 |   max-width: 100%;
58 |   transform: translateZ(0);
59 |   transition: all .25s linear;
60 | }
61 | .item-title{
62 | 	line-height: 3rem;
63 |   font-size: 1.2rem;
64 | }
65 | .item-desc{
66 |   text-align: left;
67 |   white-space: pre-line;
68 | }


--------------------------------------------------------------------------------
/pages/index/index.js:
--------------------------------------------------------------------------------
 1 | //index.js
 2 | //获取应用实例
 3 | var util = require('../../util/util.js');
 4 | var app = getApp()
 5 | var config = app.globalData.config;
 6 | Page({
 7 |   data: {
 8 |     list: [],
 9 |     site: app.globalData.site
10 |   },
11 |   fetchList: function(success, fail, paged){
12 |     var paged = paged || 1
13 |     var that = this;
14 |     wx.request({
15 |       url: config.apiUrl + '/issues',
16 |       success: function(res){
17 |         wx.setStorage({
18 |           key: 'list',
19 |           data: res.data
20 |         })
21 |         success(res.data);
22 |       },
23 |       fail: fail
24 |     })
25 |   },
26 | 
27 |   getList: function(){
28 |     var that = this;
29 |     return new Promise(function(resolve, reject){
30 |       wx.getStorage({
31 |         key: 'list',
32 |         success: function(res){
33 |           if(res.data && res.data.length){
34 |             resolve(res.data);
35 |             // that.fetchList() // 更新数据
36 |           }else{
37 |             that.getList(function(data){
38 |               resolve(res.data)
39 |             })
40 |           }
41 |         },
42 |         fail: function(){
43 |           that.fetchList(function(data){
44 |             resolve(data)
45 |           }, function(){
46 |             reject({message: 'can\'t get data'})
47 |           })
48 |         }
49 |       })
50 |     })
51 |   },
52 | 
53 |   onLoad: function () {
54 |     var that = this;
55 |     this.getList().then(function(data){
56 |       that.setData({
57 |         list: data.map(function(item){
58 |           item.summary = util.cutStr(item.body, 100);
59 |           item.body = util.marked(item.body);
60 |           return item;
61 |         })
62 |       })
63 |     })
64 |   },
65 | 
66 |   gotoDetail(e){
67 |     var itemid = e.currentTarget.dataset.itemid
68 |     var itemdata = this.data.list.find(function(it){
69 |       return it.number == itemid;
70 |     })
71 |     app.globalData.detailData = {
72 |       id: itemid,
73 |       item: itemdata
74 |     }
75 |     if(itemdata){
76 |       wx.navigateTo({
77 |         url: '/pages/detail/index',
78 |         success: function(){
79 |         },
80 |         fail: function(){
81 |           app.globalData.detailData = null;
82 |         }
83 |       })
84 |     }
85 |   }
86 | })
87 | 


--------------------------------------------------------------------------------
/wxParse/wxParse.wxss:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * author: Di (微信小程序开发工程师)
  4 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  5 |  *               垂直微信小程序开发交流社区
  6 |  * 
  7 |  * github地址: https://github.com/icindy/wxParse
  8 |  * 
  9 |  * for: 微信小程序富文本解析
 10 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 11 |  */
 12 | 
 13 | .wxParse{
 14 |     margin: 0 5px;
 15 |     font-family:Courier, Calibri,"宋体";
 16 | }
 17 | view{
 18 |     word-break:break-all; overflow:auto;
 19 | }
 20 | /*//标题 */
 21 | .wxParse-div{margin: 0;padding: 0;}
 22 | .wxParse-h1{ font-size:2em; margin: .67em 0 }
 23 | .wxParse-h2{ font-size:1.5em; margin: .75em 0 }
 24 | .wxParse-h3{ font-size:1.17em; margin: .83em 0 }
 25 | .wxParse-h4{ margin: 1.12em 0}
 26 | .wxParse-h5 { font-size:.83em; margin: 1.5em 0 }
 27 | .wxParse-h6{ font-size:.75em; margin: 1.67em 0 }
 28 | 
 29 | .wxParse-h1, .wxParse-h2, .wxParse-h3, .wxParse-h4, .wxParse-h5, .wxParse-h6, .wxParse-b, .wxParse-strong  { font-weight: bolder }
 30 | 
 31 | .wxParse-i,.wxParse-cite,.wxParse-em,.wxParse-var,.wxParse-address{font-style:italic}
 32 | .wxParse-pre,.wxParse-tt,.wxParse-code,.wxParse-kbd,.wxParse-samp{font-family:monospace}
 33 | .wxParse-pre{white-space:pre}
 34 | .wxParse-big{font-size:1.17em}
 35 | .wxParse-small,.wxParse-sub,.wxParse-sup{font-size:.83em}
 36 | .wxParse-sub{vertical-align:sub}
 37 | .wxParse-sup{vertical-align:super}
 38 | .wxParse-s,.wxParse-strike,.wxParse-del{text-decoration:line-through}
 39 | /*wxparse-自定义个性化的css样式*/
 40 | /*增加video的css样式*/
 41 | 
 42 | .wxParse-a{
 43 |     color: deepskyblue;
 44 |     word-break:break-all;
 45 |     overflow:auto;
 46 | }
 47 | 
 48 | .wxParse-video{
 49 |     text-align: center;
 50 |     margin: 10px 0;
 51 | }
 52 | 
 53 | .wxParse-video-video{
 54 |     width:100%;
 55 | }
 56 | 
 57 | .wxParse-img{
 58 |     padding: 2px;
 59 |     background-color: #efefef;
 60 |     margin: 3px;
 61 |     overflow: hidden;
 62 |     text-align: center;
 63 | }
 64 | 
 65 | .wxParse-blockquote {
 66 |     margin: 0;
 67 |     padding:10px 0 10px 5px;
 68 |     font-family:Courier, Calibri,"宋体";
 69 |     background:#f5f5f5;
 70 |     border-left: 3px solid #dbdbdb;
 71 | }
 72 | 
 73 | .wxParse-code,.wxParse-wxxxcode-style{
 74 |     text-indent:0;
 75 |     /*border-color:#000;*/
 76 |     /*border-style:dashed;*/
 77 |     border-width:1px;
 78 |     display:block;
 79 |     font-size:12px;
 80 |     font-family:Courier, Calibri,"宋体";
 81 |     margin:10px 0 0 0;
 82 |     padding:10px 0 10px 10px;
 83 |     border-radius:5px;
 84 |     background:#555;
 85 |     color:#fefefe;
 86 |     overflow: hidden;
 87 | }
 88 | 
 89 | 
 90 | 
 91 | .wxParse-ul{
 92 |     margin: 20rpx 10rpx;
 93 | }
 94 | 
 95 | .wxParse-li,.wxParse-li-inner{
 96 |     display: flex;
 97 |     align-items: baseline;
 98 |     margin: 10rpx 0;
 99 | }
100 | .wxParse-li-text{
101 |     
102 |     align-items: center;
103 |     line-height: 20px;
104 | }
105 | 
106 | .wxParse-li-circle{
107 |     display: inline-flex;
108 |     width: 5px;
109 |     height: 5px;
110 |     /*border-radius: 50%;*/
111 |     background-color: #333;
112 |     margin-right: 5px;
113 | }
114 | 
115 | .wxParse-li-square{
116 |     display: inline-flex;
117 |     width: 10rpx;
118 |     height: 10rpx;
119 |     background-color: #333;
120 |     margin-right: 5px;
121 | }
122 | .wxParse-li-ring{
123 |     display: inline-flex;
124 |     width: 10rpx;
125 |     height: 10rpx;
126 |     border: 2rpx solid #333;
127 |     border-radius: 50%;
128 |     background-color: #fff;
129 |     margin-right: 5px;
130 | }
131 | 
132 | 
133 | 


--------------------------------------------------------------------------------
/wxParse/html2json.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * author: Di (微信小程序开发工程师)
  3 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  4 |  *               垂直微信小程序开发交流社区
  5 |  * 
  6 |  * github地址: https://github.com/icindy/wxParse
  7 |  * 
  8 |  * for: 微信小程序富文本解析
  9 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 10 |  */
 11 |   var HTMLParser = require('htmlparser.js');
 12 | 
 13 |   function q(v) {
 14 |     return '"' + v + '"';
 15 |   }
 16 | 
 17 |   function removeDOCTYPE(html) {
 18 |     return html
 19 |       .replace(/<\?xml.*\?>\n/, '')
 20 |       .replace(/<!doctype.*\>\n/, '')
 21 |       .replace(/<!DOCTYPE.*\>\n/, '');
 22 |   }
 23 | 
 24 |   function html2json(html) {
 25 |     html = removeDOCTYPE(html);
 26 |     var bufArray = [];
 27 |     var results = {
 28 |       node: 'root',
 29 |       child: [],
 30 |     };
 31 |     HTMLParser(html, {
 32 |       start: function(tag, attrs, unary) {
 33 |         //debug(tag, attrs, unary);
 34 |         // node for this element
 35 |         var node = {
 36 |           node: 'element',
 37 |           tag: tag,
 38 |         };
 39 |         if (attrs.length !== 0) {
 40 |           node.attr = attrs.reduce(function(pre, attr) {
 41 |             var name = attr.name;
 42 |             var value = attr.value;
 43 | 
 44 |             // has multi attibutes
 45 |             // make it array of attribute
 46 |             if (value.match(/ /)) {
 47 |               value = value.split(' ');
 48 |             }
 49 | 
 50 |             // if attr already exists
 51 |             // merge it
 52 |             if (pre[name]) {
 53 |               if (Array.isArray(pre[name])) {
 54 |                 // already array, push to last
 55 |                 pre[name].push(value);
 56 |               } else {
 57 |                 // single value, make it array
 58 |                 pre[name] = [pre[name], value];
 59 |               }
 60 |             } else {
 61 |               // not exist, put it
 62 |               pre[name] = value;
 63 |             }
 64 | 
 65 |             return pre;
 66 |           }, {});
 67 |         }
 68 |         if (unary) {
 69 |           // if this tag dosen't have end tag
 70 |           // like <img src="hoge.png"/>
 71 |           // add to parents
 72 |           var parent = bufArray[0] || results;
 73 |           if (parent.child === undefined) {
 74 |             parent.child = [];
 75 |           }
 76 |           parent.child.push(node);
 77 |         } else {
 78 |           bufArray.unshift(node);
 79 |         }
 80 |       },
 81 |       end: function(tag) {
 82 |         //debug(tag);
 83 |         // merge into parent tag
 84 |         var node = bufArray.shift();
 85 |         if (node.tag !== tag) console.error('invalid state: mismatch end tag');
 86 | 
 87 |         if (bufArray.length === 0) {
 88 |           results.child.push(node);
 89 |         } else {
 90 |           var parent = bufArray[0];
 91 |           if (parent.child === undefined) {
 92 |             parent.child = [];
 93 |           }
 94 |           parent.child.push(node);
 95 |         }
 96 |       },
 97 |       chars: function(text) {
 98 |         //debug(text);
 99 |         var node = {
100 |           node: 'text',
101 |           text: text,
102 |         };
103 |         if (bufArray.length === 0) {
104 |           results.child.push(node);
105 |         } else {
106 |           var parent = bufArray[0];
107 |           if (parent.child === undefined) {
108 |             parent.child = [];
109 |           }
110 |           parent.child.push(node);
111 |         }
112 |       },
113 |       comment: function(text) {
114 |         //debug(text);
115 |         var node = {
116 |           node: 'comment',
117 |           text: text,
118 |         };
119 |         var parent = bufArray[0];
120 |         if (parent.child === undefined) {
121 |           parent.child = [];
122 |         }
123 |         parent.child.push(node);
124 |       },
125 |     });
126 |     return results;
127 |   };
128 | 
129 |   function json2html(json) {
130 |     // Empty Elements - HTML 4.01
131 |     var empty = ['area', 'base', 'basefont', 'br', 'col', 'frame', 'hr', 'img', 'input', 'isindex', 'link', 'meta', 'param', 'embed'];
132 | 
133 |     var child = '';
134 |     if (json.child) {
135 |       child = json.child.map(function(c) {
136 |         return json2html(c);
137 |       }).join('');
138 |     }
139 | 
140 |     var attr = '';
141 |     if (json.attr) {
142 |       attr = Object.keys(json.attr).map(function(key) {
143 |         var value = json.attr[key];
144 |         if (Array.isArray(value)) value = value.join(' ');
145 |         return key + '=' + q(value);
146 |       }).join(' ');
147 |       if (attr !== '') attr = ' ' + attr;
148 |     }
149 | 
150 |     if (json.node === 'element') {
151 |       var tag = json.tag;
152 |       if (empty.indexOf(tag) > -1) {
153 |         // empty element
154 |         return '<' + json.tag + attr + '/>';
155 |       }
156 | 
157 |       // non empty element
158 |       var open = '<' + json.tag + attr + '>';
159 |       var close = '</' + json.tag + '>';
160 |       return open + child + close;
161 |     }
162 | 
163 |     if (json.node === 'text') {
164 |       return json.text;
165 |     }
166 | 
167 |     if (json.node === 'comment') {
168 |       return '<!--' + json.text + '-->';
169 |     }
170 | 
171 |     if (json.node === 'root') {
172 |       return child;
173 |     }
174 |   };
175 | 
176 |   module.exports = html2json;
177 |   
178 | 


--------------------------------------------------------------------------------
/wxParse/wxDiscode.js:
--------------------------------------------------------------------------------
  1 | // HTML 支持的数学符号
  2 | function strNumDiscode(str){
  3 |     str = str.replace(/&forall;/g, '∀');
  4 |     str = str.replace(/&part;/g, '∂');
  5 |     str = str.replace(/&exists;/g, '∃');
  6 |     str = str.replace(/&empty;/g, '∅');
  7 |     str = str.replace(/&nabla;/g, '∇');
  8 |     str = str.replace(/&isin;/g, '∈');
  9 |     str = str.replace(/&notin;/g, '∉');
 10 |     str = str.replace(/&ni;/g, '∋');
 11 |     str = str.replace(/&prod;/g, '∏');
 12 |     str = str.replace(/&sum;/g, '∑');
 13 |     str = str.replace(/&minus;/g, '−');
 14 |     str = str.replace(/&lowast;/g, '∗');
 15 |     str = str.replace(/&radic;/g, '√');
 16 |     str = str.replace(/&prop;/g, '∝');
 17 |     str = str.replace(/&infin;/g, '∞');
 18 |     str = str.replace(/&ang;/g, '∠');
 19 |     str = str.replace(/&and;/g, '∧');
 20 |     str = str.replace(/&or;/g, '∨');
 21 |     str = str.replace(/&cap;/g, '∩');
 22 |     str = str.replace(/&cap;/g, '∪');
 23 |     str = str.replace(/&int;/g, '∫');
 24 |     str = str.replace(/&there4;/g, '∴');
 25 |     str = str.replace(/&sim;/g, '∼');
 26 |     str = str.replace(/&cong;/g, '≅');
 27 |     str = str.replace(/&asymp;/g, '≈');
 28 |     str = str.replace(/&ne;/g, '≠');
 29 |     str = str.replace(/&le;/g, '≤');
 30 |     str = str.replace(/&ge;/g, '≥');
 31 |     str = str.replace(/&sub;/g, '⊂');
 32 |     str = str.replace(/&sup;/g, '⊃');
 33 |     str = str.replace(/&nsub;/g, '⊄');
 34 |     str = str.replace(/&sube;/g, '⊆');
 35 |     str = str.replace(/&supe;/g, '⊇');
 36 |     str = str.replace(/&oplus;/g, '⊕');
 37 |     str = str.replace(/&otimes;/g, '⊗');
 38 |     str = str.replace(/&perp;/g, '⊥');
 39 |     str = str.replace(/&sdot;/g, '⋅');
 40 |     return str;
 41 | }
 42 | 
 43 | //HTML 支持的希腊字母
 44 | function strGreeceDiscode(str){
 45 |     str = str.replace(/&Alpha;/g, 'Α');
 46 |     str = str.replace(/&Beta;/g, 'Β');
 47 |     str = str.replace(/&Gamma;/g, 'Γ');
 48 |     str = str.replace(/&Delta;/g, 'Δ');
 49 |     str = str.replace(/&Epsilon;/g, 'Ε');
 50 |     str = str.replace(/&Zeta;/g, 'Ζ');
 51 |     str = str.replace(/&Eta;/g, 'Η');
 52 |     str = str.replace(/&Theta;/g, 'Θ');
 53 |     str = str.replace(/&Iota;/g, 'Ι');
 54 |     str = str.replace(/&Kappa;/g, 'Κ');
 55 |     str = str.replace(/&Lambda;/g, 'Λ');
 56 |     str = str.replace(/&Mu;/g, 'Μ');
 57 |     str = str.replace(/&Nu;/g, 'Ν');
 58 |     str = str.replace(/&Xi;/g, 'Ν');
 59 |     str = str.replace(/&Omicron;/g, 'Ο');
 60 |     str = str.replace(/&Pi;/g, 'Π');
 61 |     str = str.replace(/&Rho;/g, 'Ρ');
 62 |     str = str.replace(/&Sigma;/g, 'Σ');
 63 |     str = str.replace(/&Tau;/g, 'Τ');
 64 |     str = str.replace(/&Upsilon;/g, 'Υ');
 65 |     str = str.replace(/&Phi;/g, 'Φ');
 66 |     str = str.replace(/&Chi;/g, 'Χ');
 67 |     str = str.replace(/&Psi;/g, 'Ψ');
 68 |     str = str.replace(/&Omega;/g, 'Ω');
 69 | 
 70 |     str = str.replace(/&alpha;/g, 'α');
 71 |     str = str.replace(/&beta;/g, 'β');
 72 |     str = str.replace(/&gamma;/g, 'γ');
 73 |     str = str.replace(/&delta;/g, 'δ');
 74 |     str = str.replace(/&epsilon;/g, 'ε');
 75 |     str = str.replace(/&zeta;/g, 'ζ');
 76 |     str = str.replace(/&eta;/g, 'η');
 77 |     str = str.replace(/&theta;/g, 'θ');
 78 |     str = str.replace(/&iota;/g, 'ι');
 79 |     str = str.replace(/&kappa;/g, 'κ');
 80 |     str = str.replace(/&lambda;/g, 'λ');
 81 |     str = str.replace(/&mu;/g, 'μ');
 82 |     str = str.replace(/&nu;/g, 'ν');
 83 |     str = str.replace(/&xi;/g, 'ξ');
 84 |     str = str.replace(/&omicron;/g, 'ο');
 85 |     str = str.replace(/&pi;/g, 'π');
 86 |     str = str.replace(/&rho;/g, 'ρ');
 87 |     str = str.replace(/&sigmaf;/g, 'ς');
 88 |     str = str.replace(/&sigma;/g, 'σ');
 89 |     str = str.replace(/&tau;/g, 'τ');
 90 |     str = str.replace(/&upsilon;/g, 'υ');
 91 |     str = str.replace(/&phi;/g, 'φ');
 92 |     str = str.replace(/&chi;/g, 'χ');
 93 |     str = str.replace(/&psi;/g, 'ψ');
 94 |     str = str.replace(/&omega;/g, 'ω');
 95 |     str = str.replace(/&thetasym;/g, 'ϑ');
 96 |     str = str.replace(/&upsih;/g, 'ϒ');
 97 |     str = str.replace(/&piv;/g, 'ϖ');
 98 | 
 99 |     return str;
100 | }
101 | 
102 | // 
103 | 
104 | function strcharacterDiscode(str){
105 |     // 加入常用解析
106 |     str = str.replace(/&nbsp;/g, ' ');
107 |     str = str.replace(/&quot;/g, '"');
108 |     str = str.replace(/&amp;/g, '&');
109 |     str = str.replace(/&lt;/g, '<');
110 |     str = str.replace(/&gt;/g, '>');
111 | 
112 |     return str;
113 | }
114 | 
115 | // HTML 支持的其他实体
116 | function strOtherDiscode(str){
117 |     str = str.replace(/&OElig;/g, 'Œ');
118 |     str = str.replace(/&oelig;/g, 'œ');
119 |     str = str.replace(/&Scaron;/g, 'Š');
120 |     str = str.replace(/&scaron;/g, 'š');
121 |     str = str.replace(/&Yuml;/g, 'Ÿ');
122 |     str = str.replace(/&fnof;/g, 'ƒ');
123 |     str = str.replace(/&circ;/g, 'ˆ');
124 |     str = str.replace(/&tilde;/g, '˜');
125 |     str = str.replace(/&ensp;/g, '');
126 |     str = str.replace(/&emsp;/g, '');
127 |     str = str.replace(/&thinsp;/g, '');
128 |     str = str.replace(/&zwnj;/g, '');
129 |     str = str.replace(/&zwj;/g, '');
130 |     str = str.replace(/&lrm;/g, '');
131 |     str = str.replace(/&rlm;/g, '');
132 |     str = str.replace(/&ndash;/g, '–');
133 |     str = str.replace(/&mdash;/g, '—');
134 |     str = str.replace(/&lsquo;/g, '‘');
135 |     str = str.replace(/&rsquo;/g, '’');
136 |     str = str.replace(/&sbquo;/g, '‚');
137 |     str = str.replace(/&ldquo;/g, '“');
138 |     str = str.replace(/&rdquo;/g, '”');
139 |     str = str.replace(/&bdquo;/g, '„');
140 |     str = str.replace(/&dagger;/g, '†');
141 |     str = str.replace(/&Dagger;/g, '‡');
142 |     str = str.replace(/&bull;/g, '•');
143 |     str = str.replace(/&hellip;/g, '…');
144 |     str = str.replace(/&permil;/g, '‰');
145 |     str = str.replace(/&prime;/g, '′');
146 |     str = str.replace(/&Prime;/g, '″');
147 |     str = str.replace(/&lsaquo;/g, '‹');
148 |     str = str.replace(/&rsaquo;/g, '›');
149 |     str = str.replace(/&oline;/g, '‾');
150 |     str = str.replace(/&euro;/g, '€');
151 |     str = str.replace(/&trade;/g, '™');
152 | 
153 |     str = str.replace(/&larr;/g, '←');
154 |     str = str.replace(/&uarr;/g, '↑');
155 |     str = str.replace(/&rarr;/g, '→');
156 |     str = str.replace(/&darr;/g, '↓');
157 |     str = str.replace(/&harr;/g, '↔');
158 |     str = str.replace(/&crarr;/g, '↵');
159 |     str = str.replace(/&lceil;/g, '⌈');
160 |     str = str.replace(/&rceil;/g, '⌉');
161 | 
162 |     str = str.replace(/&lfloor;/g, '⌊');
163 |     str = str.replace(/&rfloor;/g, '⌋');
164 |     str = str.replace(/&loz;/g, '◊');
165 |     str = str.replace(/&spades;/g, '♠');
166 |     str = str.replace(/&clubs;/g, '♣');
167 |     str = str.replace(/&hearts;/g, '♥');
168 | 
169 |     str = str.replace(/&diams;/g, '♦');
170 | 
171 |     return str;
172 | }
173 | 
174 | function strMoreDiscode(str){
175 |     str = str.replace(/\r\n/g,"");  
176 |     str = str.replace(/\n\n/g,"\n");
177 |     str = str.replace(/code/g,"wxxxcode-style");
178 |     return str;
179 | }
180 | 
181 | function strDiscode(str){
182 |     str = strNumDiscode(str);
183 |     str = strGreeceDiscode(str);
184 |     str = strcharacterDiscode(str);
185 |     str = strOtherDiscode(str);
186 |     str = strMoreDiscode(str);
187 |     return str;
188 | }
189 | 
190 | module.exports = {
191 |     strDiscode:strDiscode
192 | }


--------------------------------------------------------------------------------
/wxParse/htmlparser.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * author: Di (微信小程序开发工程师)
  3 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  4 |  *               垂直微信小程序开发交流社区
  5 |  * 
  6 |  * github地址: https://github.com/icindy/wxParse
  7 |  * 
  8 |  * for: 微信小程序富文本解析
  9 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 10 |  */
 11 | 	// Regular Expressions for parsing tags and attributes
 12 | 	var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
 13 | 		endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/,
 14 | 		attr = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
 15 | 
 16 | 	// Empty Elements - HTML 5
 17 | 	var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr");
 18 | 
 19 | 	// Block Elements - HTML 5
 20 | 	var block = makeMap("a,address,article,applet,aside,audio,blockquote,button,canvas,center,dd,del,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frameset,h1,h2,h3,h4,h5,h6,header,hgroup,hr,iframe,ins,isindex,li,map,menu,noframes,noscript,object,ol,output,p,pre,section,script,table,tbody,td,tfoot,th,thead,tr,ul,video");
 21 | 
 22 | 	// Inline Elements - HTML 5
 23 | 	var inline = makeMap("abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
 24 | 
 25 | 	// Elements that you can, intentionally, leave open
 26 | 	// (and which close themselves)
 27 | 	var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
 28 | 
 29 | 	// Attributes that have their values filled in disabled="disabled"
 30 | 	var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
 31 | 
 32 | 	// Special Elements (can contain anything)
 33 | 	var special = makeMap("wxxxcode-style,script,style,view,scroll-view,block");
 34 | 
 35 | 	function HTMLParser(html, handler) {
 36 | 		var index, chars, match, stack = [], last = html;
 37 | 		stack.last = function () {
 38 | 			return this[this.length - 1];
 39 | 		};
 40 | 
 41 | 		while (html) {
 42 | 			chars = true;
 43 | 
 44 | 			// Make sure we're not in a script or style element
 45 | 			if (!stack.last() || !special[stack.last()]) {
 46 | 
 47 | 				// Comment
 48 | 				if (html.indexOf("<!--") == 0) {
 49 | 					index = html.indexOf("-->");
 50 | 
 51 | 					if (index >= 0) {
 52 | 						if (handler.comment)
 53 | 							handler.comment(html.substring(4, index));
 54 | 						html = html.substring(index + 3);
 55 | 						chars = false;
 56 | 					}
 57 | 
 58 | 					// end tag
 59 | 				} else if (html.indexOf("</") == 0) {
 60 | 					match = html.match(endTag);
 61 | 
 62 | 					if (match) {
 63 | 						html = html.substring(match[0].length);
 64 | 						match[0].replace(endTag, parseEndTag);
 65 | 						chars = false;
 66 | 					}
 67 | 
 68 | 					// start tag
 69 | 				} else if (html.indexOf("<") == 0) {
 70 | 					match = html.match(startTag);
 71 | 
 72 | 					if (match) {
 73 | 						html = html.substring(match[0].length);
 74 | 						match[0].replace(startTag, parseStartTag);
 75 | 						chars = false;
 76 | 					}
 77 | 				}
 78 | 
 79 | 				if (chars) {
 80 | 					index = html.indexOf("<");
 81 | 
 82 | 					var text = index < 0 ? html : html.substring(0, index);
 83 | 					html = index < 0 ? "" : html.substring(index);
 84 | 
 85 | 					if (handler.chars)
 86 | 						handler.chars(text);
 87 | 				}
 88 | 
 89 | 			} else {
 90 | 				
 91 | 
 92 | 				// if(special[stack.last()]){
 93 | 				// 	console.log("code");
 94 | 				// }else{
 95 | 				// 	html = html.replace(new RegExp("([\\s\\S]*?)<\/" + stack.last() + "[^>]*>"), function (all, text) {
 96 | 				// 		text = text.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g, "$1$2");
 97 | 				// 		if (handler.chars)
 98 | 				// 			handler.chars(text);
 99 | 
100 | 				// 		return "";
101 | 				// 	});
102 | 				// }
103 | 
104 | 				html = html.replace(new RegExp("([\\s\\S]*?)<\/" + stack.last() + "[^>]*>"), function (all, text) {
105 | 						text = text.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g, "$1$2");
106 | 						if (handler.chars)
107 | 							handler.chars(text);
108 | 
109 | 						return "";
110 | 					});
111 | 
112 | 				
113 | 				parseEndTag("", stack.last());
114 | 			}
115 | 
116 | 			if (html == last)
117 | 				throw "Parse Error: " + html;
118 | 			last = html;
119 | 		}
120 | 
121 | 		// Clean up any remaining tags
122 | 		parseEndTag();
123 | 
124 | 		function parseStartTag(tag, tagName, rest, unary) {
125 | 			tagName = tagName.toLowerCase();
126 | 
127 | 			if (block[tagName]) {
128 | 				while (stack.last() && inline[stack.last()]) {
129 | 					parseEndTag("", stack.last());
130 | 				}
131 | 			}
132 | 
133 | 			if (closeSelf[tagName] && stack.last() == tagName) {
134 | 				parseEndTag("", tagName);
135 | 			}
136 | 
137 | 			unary = empty[tagName] || !!unary;
138 | 
139 | 			if (!unary)
140 | 				stack.push(tagName);
141 | 
142 | 			if (handler.start) {
143 | 				var attrs = [];
144 | 
145 | 				rest.replace(attr, function (match, name) {
146 | 					var value = arguments[2] ? arguments[2] :
147 | 						arguments[3] ? arguments[3] :
148 | 						arguments[4] ? arguments[4] :
149 | 						fillAttrs[name] ? name : "";
150 | 
151 | 					attrs.push({
152 | 						name: name,
153 | 						value: value,
154 | 						escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
155 | 					});
156 | 				});
157 | 
158 | 				if (handler.start)
159 | 					handler.start(tagName, attrs, unary);
160 | 			}
161 | 		}
162 | 
163 | 		function parseEndTag(tag, tagName) {
164 | 			// If no tag name is provided, clean shop
165 | 			if (!tagName)
166 | 				var pos = 0;
167 | 
168 | 				// Find the closest opened tag of the same type
169 | 			else
170 | 				for (var pos = stack.length - 1; pos >= 0; pos--)
171 | 					if (stack[pos] == tagName)
172 | 						break;
173 | 
174 | 			if (pos >= 0) {
175 | 				// Close all the open elements, up the stack
176 | 				for (var i = stack.length - 1; i >= pos; i--)
177 | 					if (handler.end)
178 | 						handler.end(stack[i]);
179 | 
180 | 				// Remove the open elements from the stack
181 | 				stack.length = pos;
182 | 			}
183 | 		}
184 | 	};
185 | 
186 | 	function HTMLtoXML(html) {
187 | 		var results = "";
188 | 
189 | 		HTMLParser(html, {
190 | 			start: function (tag, attrs, unary) {
191 | 				results += "<" + tag;
192 | 
193 | 				for (var i = 0; i < attrs.length; i++)
194 | 					results += " " + attrs[i].name + '="' + attrs[i].escaped + '"';
195 | 				results += ">";
196 | 			},
197 | 			end: function (tag) {
198 | 				results += "</" + tag + ">";
199 | 			},
200 | 			chars: function (text) {
201 | 				results += text;
202 | 			},
203 | 			comment: function (text) {
204 | 				results += "<!--" + text + "-->";
205 | 			}
206 | 		});
207 | 
208 | 		return results;
209 | 	};
210 | 
211 | 	function HTMLtoDOM(html, doc) {
212 | 		// There can be only one of these elements
213 | 		var one = makeMap("html,head,body,title");
214 | 
215 | 		// Enforce a structure for the document
216 | 		var structure = {
217 | 			link: "head",
218 | 			base: "head"
219 | 		};
220 | 
221 | 		if (!doc) {
222 | 			if (typeof DOMDocument != "undefined")
223 | 				doc = new DOMDocument();
224 | 			else if (typeof document != "undefined" && document.implementation && document.implementation.createDocument)
225 | 				doc = document.implementation.createDocument("", "", null);
226 | 			else if (typeof ActiveX != "undefined")
227 | 				doc = new ActiveXObject("Msxml.DOMDocument");
228 | 
229 | 		} else
230 | 			doc = doc.ownerDocument ||
231 | 				doc.getOwnerDocument && doc.getOwnerDocument() ||
232 | 				doc;
233 | 
234 | 		var elems = [],
235 | 			documentElement = doc.documentElement ||
236 | 				doc.getDocumentElement && doc.getDocumentElement();
237 | 
238 | 		// If we're dealing with an empty document then we
239 | 		// need to pre-populate it with the HTML document structure
240 | 		if (!documentElement && doc.createElement) (function () {
241 | 			var html = doc.createElement("html");
242 | 			var head = doc.createElement("head");
243 | 			head.appendChild(doc.createElement("title"));
244 | 			html.appendChild(head);
245 | 			html.appendChild(doc.createElement("body"));
246 | 			doc.appendChild(html);
247 | 		})();
248 | 
249 | 		// Find all the unique elements
250 | 		if (doc.getElementsByTagName)
251 | 			for (var i in one)
252 | 				one[i] = doc.getElementsByTagName(i)[0];
253 | 
254 | 		// If we're working with a document, inject contents into
255 | 		// the body element
256 | 		var curParentNode = one.body;
257 | 
258 | 		HTMLParser(html, {
259 | 			start: function (tagName, attrs, unary) {
260 | 				// If it's a pre-built element, then we can ignore
261 | 				// its construction
262 | 				if (one[tagName]) {
263 | 					curParentNode = one[tagName];
264 | 					if (!unary) {
265 | 						elems.push(curParentNode);
266 | 					}
267 | 					return;
268 | 				}
269 | 
270 | 				var elem = doc.createElement(tagName);
271 | 
272 | 				for (var attr in attrs)
273 | 					elem.setAttribute(attrs[attr].name, attrs[attr].value);
274 | 
275 | 				if (structure[tagName] && typeof one[structure[tagName]] != "boolean")
276 | 					one[structure[tagName]].appendChild(elem);
277 | 
278 | 				else if (curParentNode && curParentNode.appendChild)
279 | 					curParentNode.appendChild(elem);
280 | 
281 | 				if (!unary) {
282 | 					elems.push(elem);
283 | 					curParentNode = elem;
284 | 				}
285 | 			},
286 | 			end: function (tag) {
287 | 				elems.length -= 1;
288 | 
289 | 				// Init the new parentNode
290 | 				curParentNode = elems[elems.length - 1];
291 | 			},
292 | 			chars: function (text) {
293 | 				curParentNode.appendChild(doc.createTextNode(text));
294 | 			},
295 | 			comment: function (text) {
296 | 				// create comment node
297 | 			}
298 | 		});
299 | 
300 | 		return doc;
301 | 	};
302 | 
303 | 	function makeMap(str) {
304 | 		var obj = {}, items = str.split(",");
305 | 		for (var i = 0; i < items.length; i++)
306 | 			obj[items[i]] = true;
307 | 		return obj;
308 | 	}
309 | 
310 | 
311 | 	// CommonJS/nodeJS Loader
312 | 
313 | 	module.exports = HTMLParser;
314 | 


--------------------------------------------------------------------------------
/util/marked.min.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * marked - a markdown parser
3 |  * Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
4 |  * https://github.com/chjj/marked
5 |  */
6 | (function(){var block={newline:/^\n+/,code:/^( {4}[^\n]+\n*)+/,fences:noop,hr:/^( *[-*_]){3,} *(?:\n+|$)/,heading:/^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,nptable:noop,lheading:/^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,blockquote:/^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,list:/^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,html:/^ *(?:comment *(?:\n|\s*$)|closed *(?:\n{2,}|\s*$)|closing *(?:\n{2,}|\s*$))/,def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,table:noop,paragraph:/^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,text:/^[^\n]+/};block.bullet=/(?:[*+-]|\d+\.)/;block.item=/^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;block.item=replace(block.item,"gm")(/bull/g,block.bullet)();block.list=replace(block.list)(/bull/g,block.bullet)("hr","\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))")("def","\\n+(?="+block.def.source+")")();block.blockquote=replace(block.blockquote)("def",block.def)();block._tag="(?!(?:"+"a|em|strong|small|s|cite|q|dfn|abbr|data|time|code"+"|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo"+"|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b";block.html=replace(block.html)("comment",/<!--[\s\S]*?-->/)("closed",/<(tag)[\s\S]+?<\/\1>/)("closing",/<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)(/tag/g,block._tag)();block.paragraph=replace(block.paragraph)("hr",block.hr)("heading",block.heading)("lheading",block.lheading)("blockquote",block.blockquote)("tag","<"+block._tag)("def",block.def)();block.normal=merge({},block);block.gfm=merge({},block.normal,{fences:/^ *(`{3,}|~{3,})[ \.]*(\S+)? *\n([\s\S]*?)\s*\1 *(?:\n+|$)/,paragraph:/^/,heading:/^ *(#{1,6}) +([^\n]+?) *#* *(?:\n+|$)/});block.gfm.paragraph=replace(block.paragraph)("(?!","(?!"+block.gfm.fences.source.replace("\\1","\\2")+"|"+block.list.source.replace("\\1","\\3")+"|")();block.tables=merge({},block.gfm,{nptable:/^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,table:/^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/});function Lexer(options){this.tokens=[];this.tokens.links={};this.options=options||marked.defaults;this.rules=block.normal;if(this.options.gfm){if(this.options.tables){this.rules=block.tables}else{this.rules=block.gfm}}}Lexer.rules=block;Lexer.lex=function(src,options){var lexer=new Lexer(options);return lexer.lex(src)};Lexer.prototype.lex=function(src){src=src.replace(/\r\n|\r/g,"\n").replace(/\t/g,"    ").replace(/\u00a0/g," ").replace(/\u2424/g,"\n");return this.token(src,true)};Lexer.prototype.token=function(src,top,bq){var src=src.replace(/^ +$/gm,""),next,loose,cap,bull,b,item,space,i,l;while(src){if(cap=this.rules.newline.exec(src)){src=src.substring(cap[0].length);if(cap[0].length>1){this.tokens.push({type:"space"})}}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);cap=cap[0].replace(/^ {4}/gm,"");this.tokens.push({type:"code",text:!this.options.pedantic?cap.replace(/\n+$/,""):cap});continue}if(cap=this.rules.fences.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"code",lang:cap[2],text:cap[3]||""});continue}if(cap=this.rules.heading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[1].length,text:cap[2]});continue}if(top&&(cap=this.rules.nptable.exec(src))){src=src.substring(cap[0].length);item={type:"table",header:cap[1].replace(/^ *| *\| *$/g,"").split(/ *\| */),align:cap[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:cap[3].replace(/\n$/,"").split("\n")};for(i=0;i<item.align.length;i++){if(/^ *-+: *$/.test(item.align[i])){item.align[i]="right"}else if(/^ *:-+: *$/.test(item.align[i])){item.align[i]="center"}else if(/^ *:-+ *$/.test(item.align[i])){item.align[i]="left"}else{item.align[i]=null}}for(i=0;i<item.cells.length;i++){item.cells[i]=item.cells[i].split(/ *\| */)}this.tokens.push(item);continue}if(cap=this.rules.lheading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"heading",depth:cap[2]==="="?1:2,text:cap[1]});continue}if(cap=this.rules.hr.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"hr"});continue}if(cap=this.rules.blockquote.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"blockquote_start"});cap=cap[0].replace(/^ *> ?/gm,"");this.token(cap,top,true);this.tokens.push({type:"blockquote_end"});continue}if(cap=this.rules.list.exec(src)){src=src.substring(cap[0].length);bull=cap[2];this.tokens.push({type:"list_start",ordered:bull.length>1});cap=cap[0].match(this.rules.item);next=false;l=cap.length;i=0;for(;i<l;i++){item=cap[i];space=item.length;item=item.replace(/^ *([*+-]|\d+\.) +/,"");if(~item.indexOf("\n ")){space-=item.length;item=!this.options.pedantic?item.replace(new RegExp("^ {1,"+space+"}","gm"),""):item.replace(/^ {1,4}/gm,"")}if(this.options.smartLists&&i!==l-1){b=block.bullet.exec(cap[i+1])[0];if(bull!==b&&!(bull.length>1&&b.length>1)){src=cap.slice(i+1).join("\n")+src;i=l-1}}loose=next||/\n\n(?!\s*$)/.test(item);if(i!==l-1){next=item.charAt(item.length-1)==="\n";if(!loose)loose=next}this.tokens.push({type:loose?"loose_item_start":"list_item_start"});this.token(item,false,bq);this.tokens.push({type:"list_item_end"})}this.tokens.push({type:"list_end"});continue}if(cap=this.rules.html.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:this.options.sanitize?"paragraph":"html",pre:!this.options.sanitizer&&(cap[1]==="pre"||cap[1]==="script"||cap[1]==="style"),text:cap[0]});continue}if(!bq&&top&&(cap=this.rules.def.exec(src))){src=src.substring(cap[0].length);this.tokens.links[cap[1].toLowerCase()]={href:cap[2],title:cap[3]};continue}if(top&&(cap=this.rules.table.exec(src))){src=src.substring(cap[0].length);item={type:"table",header:cap[1].replace(/^ *| *\| *$/g,"").split(/ *\| */),align:cap[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:cap[3].replace(/(?: *\| *)?\n$/,"").split("\n")};for(i=0;i<item.align.length;i++){if(/^ *-+: *$/.test(item.align[i])){item.align[i]="right"}else if(/^ *:-+: *$/.test(item.align[i])){item.align[i]="center"}else if(/^ *:-+ *$/.test(item.align[i])){item.align[i]="left"}else{item.align[i]=null}}for(i=0;i<item.cells.length;i++){item.cells[i]=item.cells[i].replace(/^ *\| *| *\| *$/g,"").split(/ *\| */)}this.tokens.push(item);continue}if(top&&(cap=this.rules.paragraph.exec(src))){src=src.substring(cap[0].length);this.tokens.push({type:"paragraph",text:cap[1].charAt(cap[1].length-1)==="\n"?cap[1].slice(0,-1):cap[1]});continue}if(cap=this.rules.text.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:"text",text:cap[0]});continue}if(src){throw new Error("Infinite loop on byte: "+src.charCodeAt(0))}}return this.tokens};var inline={escape:/^\\([\\`*{}\[\]()#+\-.!_>])/,autolink:/^<([^ >]+(@|:\/)[^ >]+)>/,url:noop,tag:/^<!--[\s\S]*?-->|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,link:/^!?\[(inside)\]\(href\)/,reflink:/^!?\[(inside)\]\s*\[([^\]]*)\]/,nolink:/^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,strong:/^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,em:/^\b_((?:[^_]|__)+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,code:/^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,br:/^ {2,}\n(?!\s*$)/,del:noop,text:/^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/};inline._inside=/(?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*/;inline._href=/\s*<?([\s\S]*?)>?(?:\s+['"]([\s\S]*?)['"])?\s*/;inline.link=replace(inline.link)("inside",inline._inside)("href",inline._href)();inline.reflink=replace(inline.reflink)("inside",inline._inside)();inline.normal=merge({},inline);inline.pedantic=merge({},inline.normal,{strong:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,em:/^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/});inline.gfm=merge({},inline.normal,{escape:replace(inline.escape)("])","~|])")(),url:/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,del:/^~~(?=\S)([\s\S]*?\S)~~/,text:replace(inline.text)("]|","~]|")("|","|https?://|")()});inline.breaks=merge({},inline.gfm,{br:replace(inline.br)("{2,}","*")(),text:replace(inline.gfm.text)("{2,}","*")()});function InlineLexer(links,options){this.options=options||marked.defaults;this.links=links;this.rules=inline.normal;this.renderer=this.options.renderer||new Renderer;this.renderer.options=this.options;if(!this.links){throw new Error("Tokens array requires a `links` property.")}if(this.options.gfm){if(this.options.breaks){this.rules=inline.breaks}else{this.rules=inline.gfm}}else if(this.options.pedantic){this.rules=inline.pedantic}}InlineLexer.rules=inline;InlineLexer.output=function(src,links,options){var inline=new InlineLexer(links,options);return inline.output(src)};InlineLexer.prototype.output=function(src){var out="",link,text,href,cap;while(src){if(cap=this.rules.escape.exec(src)){src=src.substring(cap[0].length);out+=cap[1];continue}if(cap=this.rules.autolink.exec(src)){src=src.substring(cap[0].length);if(cap[2]==="@"){text=cap[1].charAt(6)===":"?this.mangle(cap[1].substring(7)):this.mangle(cap[1]);href=this.mangle("mailto:")+text}else{text=escape(cap[1]);href=text}out+=this.renderer.link(href,null,text);continue}if(!this.inLink&&(cap=this.rules.url.exec(src))){src=src.substring(cap[0].length);text=escape(cap[1]);href=text;out+=this.renderer.link(href,null,text);continue}if(cap=this.rules.tag.exec(src)){if(!this.inLink&&/^<a /i.test(cap[0])){this.inLink=true}else if(this.inLink&&/^<\/a>/i.test(cap[0])){this.inLink=false}src=src.substring(cap[0].length);out+=this.options.sanitize?this.options.sanitizer?this.options.sanitizer(cap[0]):escape(cap[0]):cap[0];continue}if(cap=this.rules.link.exec(src)){src=src.substring(cap[0].length);this.inLink=true;out+=this.outputLink(cap,{href:cap[2],title:cap[3]});this.inLink=false;continue}if((cap=this.rules.reflink.exec(src))||(cap=this.rules.nolink.exec(src))){src=src.substring(cap[0].length);link=(cap[2]||cap[1]).replace(/\s+/g," ");link=this.links[link.toLowerCase()];if(!link||!link.href){out+=cap[0].charAt(0);src=cap[0].substring(1)+src;continue}this.inLink=true;out+=this.outputLink(cap,link);this.inLink=false;continue}if(cap=this.rules.strong.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.strong(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.em.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.em(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.codespan(escape(cap[2],true));continue}if(cap=this.rules.br.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.br();continue}if(cap=this.rules.del.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.del(this.output(cap[1]));continue}if(cap=this.rules.text.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.text(escape(this.smartypants(cap[0])));continue}if(src){throw new Error("Infinite loop on byte: "+src.charCodeAt(0))}}return out};InlineLexer.prototype.outputLink=function(cap,link){var href=escape(link.href),title=link.title?escape(link.title):null;return cap[0].charAt(0)!=="!"?this.renderer.link(href,title,this.output(cap[1])):this.renderer.image(href,title,escape(cap[1]))};InlineLexer.prototype.smartypants=function(text){if(!this.options.smartypants)return text;return text.replace(/---/g,"—").replace(/--/g,"–").replace(/(^|[-\u2014/(\[{"\s])'/g,"$1‘").replace(/'/g,"’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g,"$1“").replace(/"/g,"”").replace(/\.{3}/g,"…")};InlineLexer.prototype.mangle=function(text){if(!this.options.mangle)return text;var out="",l=text.length,i=0,ch;for(;i<l;i++){ch=text.charCodeAt(i);if(Math.random()>.5){ch="x"+ch.toString(16)}out+="&#"+ch+";"}return out};function Renderer(options){this.options=options||{}}Renderer.prototype.code=function(code,lang,escaped){if(this.options.highlight){var out=this.options.highlight(code,lang);if(out!=null&&out!==code){escaped=true;code=out}}if(!lang){return"<pre><code>"+(escaped?code:escape(code,true))+"\n</code></pre>"}return'<pre><code class="'+this.options.langPrefix+escape(lang,true)+'">'+(escaped?code:escape(code,true))+"\n</code></pre>\n"};Renderer.prototype.blockquote=function(quote){return"<blockquote>\n"+quote+"</blockquote>\n"};Renderer.prototype.html=function(html){return html};Renderer.prototype.heading=function(text,level,raw){return"<h"+level+' id="'+this.options.headerPrefix+raw.toLowerCase().replace(/[^\w]+/g,"-")+'">'+text+"</h"+level+">\n"};Renderer.prototype.hr=function(){return this.options.xhtml?"<hr/>\n":"<hr>\n"};Renderer.prototype.list=function(body,ordered){var type=ordered?"ol":"ul";return"<"+type+">\n"+body+"</"+type+">\n"};Renderer.prototype.listitem=function(text){return"<li>"+text+"</li>\n"};Renderer.prototype.paragraph=function(text){return"<p>"+text+"</p>\n"};Renderer.prototype.table=function(header,body){return"<table>\n"+"<thead>\n"+header+"</thead>\n"+"<tbody>\n"+body+"</tbody>\n"+"</table>\n"};Renderer.prototype.tablerow=function(content){return"<tr>\n"+content+"</tr>\n"};Renderer.prototype.tablecell=function(content,flags){var type=flags.header?"th":"td";var tag=flags.align?"<"+type+' style="text-align:'+flags.align+'">':"<"+type+">";return tag+content+"</"+type+">\n"};Renderer.prototype.strong=function(text){return"<strong>"+text+"</strong>"};Renderer.prototype.em=function(text){return"<em>"+text+"</em>"};Renderer.prototype.codespan=function(text){return"<code>"+text+"</code>"};Renderer.prototype.br=function(){return this.options.xhtml?"<br/>":"<br>"};Renderer.prototype.del=function(text){return"<del>"+text+"</del>"};Renderer.prototype.link=function(href,title,text){if(this.options.sanitize){try{var prot=decodeURIComponent(unescape(href)).replace(/[^\w:]/g,"").toLowerCase()}catch(e){return""}if(prot.indexOf("javascript:")===0||prot.indexOf("vbscript:")===0){return""}}var out='<a href="'+href+'"';if(title){out+=' title="'+title+'"'}out+=">"+text+"</a>";return out};Renderer.prototype.image=function(href,title,text){var out='<img src="'+href+'" alt="'+text+'"';if(title){out+=' title="'+title+'"'}out+=this.options.xhtml?"/>":">";return out};Renderer.prototype.text=function(text){return text};function Parser(options){this.tokens=[];this.token=null;this.options=options||marked.defaults;this.options.renderer=this.options.renderer||new Renderer;this.renderer=this.options.renderer;this.renderer.options=this.options}Parser.parse=function(src,options,renderer){var parser=new Parser(options,renderer);return parser.parse(src)};Parser.prototype.parse=function(src){this.inline=new InlineLexer(src.links,this.options,this.renderer);this.tokens=src.reverse();var out="";while(this.next()){out+=this.tok()}return out};Parser.prototype.next=function(){return this.token=this.tokens.pop()};Parser.prototype.peek=function(){return this.tokens[this.tokens.length-1]||0};Parser.prototype.parseText=function(){var body=this.token.text;while(this.peek().type==="text"){body+="\n"+this.next().text}return this.inline.output(body)};Parser.prototype.tok=function(){switch(this.token.type){case"space":{return""}case"hr":{return this.renderer.hr()}case"heading":{return this.renderer.heading(this.inline.output(this.token.text),this.token.depth,this.token.text)}case"code":{return this.renderer.code(this.token.text,this.token.lang,this.token.escaped)}case"table":{var header="",body="",i,row,cell,flags,j;cell="";for(i=0;i<this.token.header.length;i++){flags={header:true,align:this.token.align[i]};cell+=this.renderer.tablecell(this.inline.output(this.token.header[i]),{header:true,align:this.token.align[i]})}header+=this.renderer.tablerow(cell);for(i=0;i<this.token.cells.length;i++){row=this.token.cells[i];cell="";for(j=0;j<row.length;j++){cell+=this.renderer.tablecell(this.inline.output(row[j]),{header:false,align:this.token.align[j]})}body+=this.renderer.tablerow(cell)}return this.renderer.table(header,body)}case"blockquote_start":{var body="";while(this.next().type!=="blockquote_end"){body+=this.tok()}return this.renderer.blockquote(body)}case"list_start":{var body="",ordered=this.token.ordered;while(this.next().type!=="list_end"){body+=this.tok()}return this.renderer.list(body,ordered)}case"list_item_start":{var body="";while(this.next().type!=="list_item_end"){body+=this.token.type==="text"?this.parseText():this.tok()}return this.renderer.listitem(body)}case"loose_item_start":{var body="";while(this.next().type!=="list_item_end"){body+=this.tok()}return this.renderer.listitem(body)}case"html":{var html=!this.token.pre&&!this.options.pedantic?this.inline.output(this.token.text):this.token.text;return this.renderer.html(html)}case"paragraph":{return this.renderer.paragraph(this.inline.output(this.token.text))}case"text":{return this.renderer.paragraph(this.parseText())}}};function escape(html,encode){return html.replace(!encode?/&(?!#?\w+;)/g:/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#39;")}function unescape(html){return html.replace(/&([#\w]+);/g,function(_,n){n=n.toLowerCase();if(n==="colon")return":";if(n.charAt(0)==="#"){return n.charAt(1)==="x"?String.fromCharCode(parseInt(n.substring(2),16)):String.fromCharCode(+n.substring(1))}return""})}function replace(regex,opt){regex=regex.source;opt=opt||"";return function self(name,val){if(!name)return new RegExp(regex,opt);val=val.source||val;val=val.replace(/(^|[^\[])\^/g,"$1");regex=regex.replace(name,val);return self}}function noop(){}noop.exec=noop;function merge(obj){var i=1,target,key;for(;i<arguments.length;i++){target=arguments[i];for(key in target){if(Object.prototype.hasOwnProperty.call(target,key)){obj[key]=target[key]}}}return obj}function marked(src,opt,callback){if(callback||typeof opt==="function"){if(!callback){callback=opt;opt=null}opt=merge({},marked.defaults,opt||{});var highlight=opt.highlight,tokens,pending,i=0;try{tokens=Lexer.lex(src,opt)}catch(e){return callback(e)}pending=tokens.length;var done=function(err){if(err){opt.highlight=highlight;return callback(err)}var out;try{out=Parser.parse(tokens,opt)}catch(e){err=e}opt.highlight=highlight;return err?callback(err):callback(null,out)};if(!highlight||highlight.length<3){return done()}delete opt.highlight;if(!pending)return done();for(;i<tokens.length;i++){(function(token){if(token.type!=="code"){return--pending||done()}return highlight(token.text,token.lang,function(err,code){if(err)return done(err);if(code==null||code===token.text){return--pending||done()}token.text=code;token.escaped=true;--pending||done()})})(tokens[i])}return}try{if(opt)opt=merge({},marked.defaults,opt);return Parser.parse(Lexer.lex(src,opt),opt)}catch(e){e.message+="\nPlease report this to https://github.com/chjj/marked.";if((opt||marked.defaults).silent){return"<p>An error occured:</p><pre>"+escape(e.message+"",true)+"</pre>"}throw e}}marked.options=marked.setOptions=function(opt){merge(marked.defaults,opt);return marked};marked.defaults={gfm:true,tables:true,breaks:false,pedantic:false,sanitize:false,sanitizer:null,mangle:true,smartLists:false,silent:false,highlight:null,langPrefix:"lang-",smartypants:false,headerPrefix:"",renderer:new Renderer,xhtml:false};marked.Parser=Parser;marked.parser=Parser.parse;marked.Renderer=Renderer;marked.Lexer=Lexer;marked.lexer=Lexer.lex;marked.InlineLexer=InlineLexer;marked.inlineLexer=InlineLexer.output;marked.parse=marked;if(true){module.exports=marked}else if(typeof define==="function"&&define.amd){define(function(){return marked})}else{this.marked=marked}}).call(function(){return module.exports}());


--------------------------------------------------------------------------------
/wxParse/wxParse.wxml:
--------------------------------------------------------------------------------
  1 | 
  2 | <!--**
  3 |  * author: Di (微信小程序开发工程师)
  4 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  5 |  *               垂直微信小程序开发交流社区
  6 |  * 
  7 |  * github地址: https://github.com/icindy/wxParse
  8 |  * 
  9 |  * for: 微信小程序富文本解析
 10 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 11 |  */-->
 12 | 
 13 | <template name="wxParse">
 14 |     <block wx:for="{{wxParseData}}" wx:key="">
 15 |         <template is="wxParse0" data="{{item}}"/>
 16 |     </block>
 17 | </template>
 18 | 
 19 | <template name="wxParse0">
 20 |     <!--<template is="wxParse1" data="{{item}}" />-->
 21 |     <!--判断是否是标签节点-->
 22 |     <block wx:if="{{item.node == 'element'}}">
 23 |         
 24 |         <block wx:if="{{item.tag == 'button'}}">
 25 |             <button type="default" size="mini" >
 26 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
 27 |                     <template is="wxParse1" data="{{item}}"/>
 28 |                 </block>
 29 |              </button>
 30 |         </block>
 31 |         <!--li类型-->
 32 |         <block wx:elif="{{item.tag == 'li'}}">
 33 |             <view class="wxParse-li">
 34 |                 <view class="wxParse-li-inner">
 35 |                     <view class="wxParse-li-text">
 36 |                         <text class="wxParse-li-circle"></text>
 37 |                     </view>
 38 |                     <view class="wxParse-li-text">
 39 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
 40 |                             <template is="wxParse1" data="{{item}}"/>
 41 |                         </block>
 42 |                     </view>
 43 |                 </view>
 44 |             </view>
 45 |         </block>
 46 | 
 47 |         <!--video类型-->
 48 |         <block wx:elif="{{item.tag == 'video'}}">
 49 |             <!--增加video标签支持，并循环添加-->
 50 |             <view  class="wxParse-{{item.tag}}">
 51 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
 52 |             </view>
 53 |             
 54 |         </block>
 55 | 
 56 |         <!--img类型-->
 57 |         <block wx:elif="{{item.tag == 'img'}}">
 58 |             <view class="wxParse-{{item.tag}}">
 59 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>
 60 |             </view>
 61 |         </block>
 62 | 
 63 |         <block wx:else>
 64 |             <view  class="wxParse-{{item.tag}}">
 65 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
 66 |                     <template is="wxParse1" data="{{item}}"/>                 
 67 |                 </block>
 68 |             </view>
 69 |         </block>
 70 | 
 71 | 
 72 |     </block>
 73 | 
 74 |     <!--判断是否是文本节点-->
 75 |     <block wx:elif="{{item.node == 'text'}}">
 76 |         <!--如果是，直接进行-->
 77 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  ' || item.text != '\n\n'}}">
 78 |             <text>{{item.text}}</text>
 79 |         </block>
 80 |     </block>
 81 | 
 82 | </template>
 83 | 
 84 | <template name="wxParse1">
 85 |     <!--<template is="wxParse1" data="{{item}}" />-->
 86 |     <!--判断是否是标签节点-->
 87 |     <block wx:if="{{item.node == 'element'}}">
 88 |         
 89 |         <block wx:if="{{item.tag == 'button'}}">
 90 |             <button type="default" size="mini" >
 91 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
 92 |                     <template is="wxParse2" data="{{item}}"/>
 93 |                 </block>
 94 |              </button>
 95 |         </block>
 96 |         <!--img类型-->
 97 |         <block wx:elif="{{item.tag == 'li'}}">
 98 |             <view class="wxParse-li">
 99 |                 <view class="wxParse-li-inner">
100 |                     <view class="wxParse-li-text">
101 |                         <text class="wxParse-li-circle"></text>
102 |                     </view>
103 |                     <view class="wxParse-li-text">
104 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
105 |                             <template is="wxParse2" data="{{item}}"/>
106 |                         </block>
107 |                     </view>
108 |                 </view>
109 |             </view>
110 |         </block>
111 | 
112 |         <!--video类型-->
113 |         <block wx:elif="{{item.tag == 'video'}}">
114 | 
115 |             <view  class="wxParse-{{item.tag}}">
116 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
117 |             </view>
118 |             
119 |         </block>
120 |         <!--img类型-->
121 |         <block wx:elif="{{item.tag == 'img'}}">
122 |             <view class="wxParse-{{item.tag}}">                 
123 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
124 |             </view>
125 |         </block>
126 | 
127 |         <block wx:else>
128 |             <view  class="wxParse-{{item.tag}}">
129 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
130 |                     <template is="wxParse2" data="{{item}}"/>                 
131 |                 </block>
132 |             </view>
133 |         </block>
134 | 
135 | 
136 |     </block>
137 | 
138 |     <!--判断是否是文本节点-->
139 |     <block wx:elif="{{item.node == 'text'}}">
140 |         <!--如果是，直接进行-->
141 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
142 |             <text>{{item.text}}</text>
143 |         </block>
144 |     </block>
145 | 
146 | </template>
147 | 
148 | <template name="wxParse2">
149 |     <!--<template is="wxParse1" data="{{item}}" />-->
150 |     <!--判断是否是标签节点-->
151 |     <block wx:if="{{item.node == 'element'}}">
152 |         
153 |         <block wx:if="{{item.tag == 'button'}}">
154 |             <button type="default" size="mini" >
155 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
156 |                     <template is="wxParse3" data="{{item}}"/>
157 |                 </block>
158 |              </button>
159 |         </block>
160 |         <!--img类型-->
161 |         <block wx:elif="{{item.tag == 'li'}}">
162 |             <view class="wxParse-li">
163 |                 <view class="wxParse-li-inner">
164 |                     <view class="wxParse-li-text">
165 |                         <text class="wxParse-li-circle"></text>
166 |                     </view>
167 |                     <view class="wxParse-li-text">
168 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
169 |                             <template is="wxParse3" data="{{item}}"/>
170 |                         </block>
171 |                     </view>
172 |                 </view>
173 |             </view>
174 |         </block>
175 | 
176 |         <!--video类型-->
177 |         <block wx:elif="{{item.tag == 'video'}}">
178 | 
179 |             <view  class="wxParse-{{item.tag}}">
180 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
181 |             </view>
182 |             
183 |         </block>
184 |         <!--img类型-->
185 |         <block wx:elif="{{item.tag == 'img'}}">
186 |             <view class="wxParse-{{item.tag}}">                 
187 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
188 |             </view>
189 |         </block>
190 | 
191 |         <block wx:else>
192 |             <view  class="wxParse-{{item.tag}}">
193 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
194 |                     <template is="wxParse3" data="{{item}}"/>                 
195 |                 </block>
196 |             </view>
197 |         </block>
198 | 
199 | 
200 |     </block>
201 | 
202 |     <!--判断是否是文本节点-->
203 |     <block wx:elif="{{item.node == 'text'}}">
204 |         <!--如果是，直接进行-->
205 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
206 |             <text>{{item.text}}</text>
207 |         </block>
208 |     </block>
209 | 
210 | </template>
211 | 
212 | <template name="wxParse3">
213 |     <!--<template is="wxParse1" data="{{item}}" />-->
214 |     <!--判断是否是标签节点-->
215 |     <block wx:if="{{item.node == 'element'}}">
216 |         
217 |         <block wx:if="{{item.tag == 'button'}}">
218 |             <button type="default" size="mini" >
219 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
220 |                     <template is="wxParse4" data="{{item}}"/>
221 |                 </block>
222 |              </button>
223 |         </block>
224 |         <!--img类型-->
225 |         <block wx:elif="{{item.tag == 'li'}}">
226 |             <view class="wxParse-li">
227 |                 <view class="wxParse-li-inner">
228 |                     <view class="wxParse-li-text">
229 |                         <text class="wxParse-li-circle"></text>
230 |                     </view>
231 |                     <view class="wxParse-li-text">
232 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
233 |                             <template is="wxParse4" data="{{item}}"/>
234 |                         </block>
235 |                     </view>
236 |                 </view>
237 |             </view>
238 |         </block>
239 | 
240 |         <!--video类型-->
241 |         <block wx:elif="{{item.tag == 'video'}}">
242 | 
243 |             <view  class="wxParse-{{item.tag}}">
244 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
245 |             </view>
246 |             
247 |         </block>
248 |         <!--img类型-->
249 |         <block wx:elif="{{item.tag == 'img'}}">
250 |             <view class="wxParse-{{item.tag}}">                 
251 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
252 |             </view>
253 |         </block>
254 | 
255 |         <block wx:else>
256 |             <view  class="wxParse-{{item.tag}}">
257 |                 <block  wx:for="{{item.child}}" wx:for-item="item">       
258 |                     <template is="wxParse4" data="{{item}}"/>                 
259 |                 </block>
260 |             </view>
261 |         </block>
262 | 
263 | 
264 |     </block>
265 | 
266 |     <!--判断是否是文本节点-->
267 |     <block wx:elif="{{item.node == 'text'}}">
268 |         <!--如果是，直接进行-->
269 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
270 |             <text>{{item.text}}</text>
271 |         </block>
272 |     </block>
273 | 
274 | </template>
275 | 
276 | <template name="wxParse4">
277 |     <!--<template is="wxParse1" data="{{item}}" />-->
278 |     <!--判断是否是标签节点-->
279 |     <block wx:if="{{item.node == 'element'}}">
280 |         
281 |         <block wx:if="{{item.tag == 'button'}}">
282 |             <button type="default" size="mini" >
283 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
284 |                     <template is="wxParse5" data="{{item}}"/>
285 |                 </block>
286 |              </button>
287 |         </block>
288 |         <!--img类型-->
289 |         <block wx:elif="{{item.tag == 'li'}}">
290 |             <view class="wxParse-li">
291 |                 <view class="wxParse-li-inner">
292 |                     <view class="wxParse-li-text">
293 |                         <text class="wxParse-li-circle"></text>
294 |                     </view>
295 |                     <view class="wxParse-li-text">
296 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
297 |                             <template is="wxParse5" data="{{item}}"/>
298 |                         </block>
299 |                     </view>
300 |                 </view>
301 |             </view>
302 |         </block>
303 | 
304 |         <!--video类型-->
305 |         <block wx:elif="{{item.tag == 'video'}}">
306 | 
307 |             <view  class="wxParse-{{item.tag}}">
308 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
309 |             </view>
310 |             
311 |         </block>
312 |         <!--img类型-->
313 |         <block wx:elif="{{item.tag == 'img'}}">
314 |             <view class="wxParse-{{item.tag}}">                 
315 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
316 |             </view>
317 |         </block>
318 | 
319 |         <block wx:else>
320 |             <view  class="wxParse-{{item.tag}}">
321 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
322 |                     <template is="wxParse5" data="{{item}}"/>                 
323 |                 </block>
324 |             </view>
325 |         </block>
326 | 
327 | 
328 |     </block>
329 | 
330 |     <!--判断是否是文本节点-->
331 |     <block wx:elif="{{item.node == 'text'}}">
332 |         <!--如果是，直接进行-->
333 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
334 |             <text>{{item.text}}</text>
335 |         </block>
336 |     </block>
337 | 
338 | </template>
339 | 
340 | <template name="wxParse5">
341 |     <!--<template is="wxParse1" data="{{item}}" />-->
342 |     <!--判断是否是标签节点-->
343 |     <block wx:if="{{item.node == 'element'}}">
344 |         
345 |         <block wx:if="{{item.tag == 'button'}}">
346 |             <button type="default" size="mini" >
347 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
348 |                     <template is="wxParse6" data="{{item}}"/>
349 |                 </block>
350 |              </button>
351 |         </block>
352 |         <!--img类型-->
353 |         <block wx:elif="{{item.tag == 'li'}}">
354 |             <view class="wxParse-li">
355 |                 <view class="wxParse-li-inner">
356 |                     <view class="wxParse-li-text">
357 |                         <text class="wxParse-li-circle"></text>
358 |                     </view>
359 |                     <view class="wxParse-li-text">
360 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
361 |                             <template is="wxParse6" data="{{item}}"/>
362 |                         </block>
363 |                     </view>
364 |                 </view>
365 |             </view>
366 |         </block>
367 | 
368 |         <!--video类型-->
369 |         <block wx:elif="{{item.tag == 'video'}}">
370 | 
371 |             <view  class="wxParse-{{item.tag}}">
372 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
373 |             </view>
374 |             
375 |         </block>
376 |         <!--img类型-->
377 |         <block wx:elif="{{item.tag == 'img'}}">
378 |             <view class="wxParse-{{item.tag}}">                 
379 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
380 |             </view>
381 |         </block>
382 | 
383 |         <block wx:else>
384 |             <view  class="wxParse-{{item.tag}}">
385 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
386 |                     <template is="wxParse6" data="{{item}}"/>                 
387 |                 </block>
388 |             </view>
389 |         </block>
390 | 
391 | 
392 |     </block>
393 | 
394 |     <!--判断是否是文本节点-->
395 |     <block wx:elif="{{item.node == 'text'}}">
396 |         <!--如果是，直接进行-->
397 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
398 |             <text>{{item.text}}</text>
399 |         </block>
400 |     </block>
401 | 
402 | </template>
403 | 
404 | <template name="wxParse6">
405 |     <!--<template is="wxParse1" data="{{item}}" />-->
406 |     <!--判断是否是标签节点-->
407 |     <block wx:if="{{item.node == 'element'}}">
408 |         
409 |         <block wx:if="{{item.tag == 'button'}}">
410 |             <button type="default" size="mini" >
411 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
412 |                     <template is="wxParse7" data="{{item}}"/>
413 |                 </block>
414 |              </button>
415 |         </block>
416 |         <!--img类型-->
417 |         <block wx:elif="{{item.tag == 'li'}}">
418 |             <view class="wxParse-li">
419 |                 <view class="wxParse-li-inner">
420 |                     <view class="wxParse-li-text">
421 |                         <text class="wxParse-li-circle"></text>
422 |                     </view>
423 |                     <view class="wxParse-li-text">
424 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
425 |                             <template is="wxParse7" data="{{item}}"/>
426 |                         </block>
427 |                     </view>
428 |                 </view>
429 |             </view>
430 |         </block>
431 | 
432 |         <!--video类型-->
433 |         <block wx:elif="{{item.tag == 'video'}}">
434 | 
435 |             <view  class="wxParse-{{item.tag}}">
436 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
437 |             </view>
438 |             
439 |         </block>
440 |         <!--img类型-->
441 |         <block wx:elif="{{item.tag == 'img'}}">
442 |             <view class="wxParse-{{item.tag}}">                 
443 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
444 |             </view>
445 |         </block>
446 | 
447 |         <block wx:else>
448 |             <view  class="wxParse-{{item.tag}}">
449 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
450 |                     <template is="wxParse7" data="{{item}}"/>                 
451 |                 </block>
452 |             </view>
453 |         </block>
454 | 
455 | 
456 |     </block>
457 | 
458 |     <!--判断是否是文本节点-->
459 |     <block wx:elif="{{item.node == 'text'}}">
460 |         <!--如果是，直接进行-->
461 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
462 |             <text>{{item.text}}</text>
463 |         </block>
464 |     </block>
465 | 
466 | </template>
467 | 
468 | 
469 | <template name="wxParse7">
470 |     <!--<template is="wxParse1" data="{{item}}" />-->
471 |     <!--判断是否是标签节点-->
472 |     <block wx:if="{{item.node == 'element'}}">
473 |         
474 |         <block wx:if="{{item.tag == 'button'}}">
475 |             <button type="default" size="mini" >
476 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
477 |                     <template is="wxParse8" data="{{item}}"/>
478 |                 </block>
479 |              </button>
480 |         </block>
481 |         <!--img类型-->
482 |         <block wx:elif="{{item.tag == 'li'}}">
483 |             <view class="wxParse-li">
484 |                 <view class="wxParse-li-inner">
485 |                     <view class="wxParse-li-text">
486 |                         <text class="wxParse-li-circle"></text>
487 |                     </view>
488 |                     <view class="wxParse-li-text">
489 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
490 |                             <template is="wxParse8" data="{{item}}"/>
491 |                         </block>
492 |                     </view>
493 |                 </view>
494 |             </view>
495 |         </block>
496 | 
497 |         <!--video类型-->
498 |         <block wx:elif="{{item.tag == 'video'}}">
499 | 
500 |             <view  class="wxParse-{{item.tag}}">
501 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
502 |             </view>
503 |             
504 |         </block>
505 |         <!--img类型-->
506 |         <block wx:elif="{{item.tag == 'img'}}">
507 |             <view class="wxParse-{{item.tag}}">                 
508 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
509 |             </view>
510 |         </block>
511 | 
512 |         <block wx:else>
513 |             <view  class="wxParse-{{item.tag}}">
514 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
515 |                     <template is="wxParse8" data="{{item}}"/>                 
516 |                 </block>
517 |             </view>
518 |         </block>
519 | 
520 | 
521 |     </block>
522 | 
523 |     <!--判断是否是文本节点-->
524 |     <block wx:elif="{{item.node == 'text'}}">
525 |         <!--如果是，直接进行-->
526 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
527 |             <text>{{item.text}}</text>
528 |         </block>
529 |     </block>
530 | 
531 | </template>
532 | 
533 | 
534 | 
535 | <template name="wxParse8">
536 |     <!--<template is="wxParse1" data="{{item}}" />-->
537 |     <!--判断是否是标签节点-->
538 |     <block wx:if="{{item.node == 'element'}}">
539 |         
540 |         <block wx:if="{{item.tag == 'button'}}">
541 |             <button type="default" size="mini" >
542 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
543 |                     <template is="wxParse9" data="{{item}}"/>
544 |                 </block>
545 |              </button>
546 |         </block>
547 |         <!--img类型-->
548 |         <block wx:elif="{{item.tag == 'li'}}">
549 |             <view class="wxParse-li">
550 |                 <view class="wxParse-li-inner">
551 |                     <view class="wxParse-li-text">
552 |                         <text class="wxParse-li-circle"></text>
553 |                     </view>
554 |                     <view class="wxParse-li-text">
555 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
556 |                             <template is="wxParse9" data="{{item}}"/>
557 |                         </block>
558 |                     </view>
559 |                 </view>
560 |             </view>
561 |         </block>
562 | 
563 |         <!--video类型-->
564 |         <block wx:elif="{{item.tag == 'video'}}">
565 | 
566 |             <view  class="wxParse-{{item.tag}}">
567 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
568 |             </view>
569 |             
570 |         </block>
571 |         <!--img类型-->
572 |         <block wx:elif="{{item.tag == 'img'}}">
573 |             <view class="wxParse-{{item.tag}}">                 
574 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
575 |             </view>
576 |         </block>
577 | 
578 |         <block wx:else>
579 |             <view  class="wxParse-{{item.tag}}">
580 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
581 |                     <template is="wxParse9" data="{{item}}"/>                 
582 |                 </block>
583 |             </view>
584 |         </block>
585 | 
586 | 
587 |     </block>
588 | 
589 |     <!--判断是否是文本节点-->
590 |     <block wx:elif="{{item.node == 'text'}}">
591 |         <!--如果是，直接进行-->
592 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
593 |             <text>{{item.text}}</text>
594 |         </block>
595 |     </block>
596 | 
597 | </template>
598 | 
599 | 
600 | 
601 | <template name="wxParse9">
602 |     <!--<template is="wxParse1" data="{{item}}" />-->
603 |     <!--判断是否是标签节点-->
604 |     <block wx:if="{{item.node == 'element'}}">
605 |         
606 |         <block wx:if="{{item.tag == 'button'}}">
607 |             <button type="default" size="mini" >
608 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
609 |                     <template is="wxParse10" data="{{item}}"/>
610 |                 </block>
611 |              </button>
612 |         </block>
613 |         <!--img类型-->
614 |         <block wx:elif="{{item.tag == 'li'}}">
615 |             <view class="wxParse-li">
616 |                 <view class="wxParse-li-inner">
617 |                     <view class="wxParse-li-text">
618 |                         <text class="wxParse-li-circle"></text>
619 |                     </view>
620 |                     <view class="wxParse-li-text">
621 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
622 |                             <template is="wxParse10" data="{{item}}"/>
623 |                         </block>
624 |                     </view>
625 |                 </view>
626 |             </view>
627 |         </block>
628 | 
629 |         <!--video类型-->
630 |         <block wx:elif="{{item.tag == 'video'}}">
631 | 
632 |             <view  class="wxParse-{{item.tag}}">
633 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
634 |             </view>
635 |             
636 |         </block>
637 |         <!--img类型-->
638 |         <block wx:elif="{{item.tag == 'img'}}">
639 |             <view class="wxParse-{{item.tag}}">                 
640 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
641 |             </view>
642 |         </block>
643 | 
644 |         <block wx:else>
645 |             <view  class="wxParse-{{item.tag}}">
646 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
647 |                     <template is="wxParse10" data="{{item}}"/>                 
648 |                 </block>
649 |             </view>
650 |         </block>
651 | 
652 | 
653 |     </block>
654 | 
655 |     <!--判断是否是文本节点-->
656 |     <block wx:elif="{{item.node == 'text'}}">
657 |         <!--如果是，直接进行-->
658 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
659 |             <text>{{item.text}}</text>
660 |         </block>
661 |     </block>
662 | 
663 | </template>
664 | 
665 | 
666 | <template name="wxParse10">
667 |     <!--<template is="wxParse1" data="{{item}}" />-->
668 |     <!--判断是否是标签节点-->
669 |     <block wx:if="{{item.node == 'element'}}">
670 |         
671 |         <block wx:if="{{item.tag == 'button'}}">
672 |             <button type="default" size="mini" >
673 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
674 |                     <template is="wxParse11" data="{{item}}"/>
675 |                 </block>
676 |              </button>
677 |         </block>
678 |         <!--img类型-->
679 |         <block wx:elif="{{item.tag == 'li'}}">
680 |             <view class="wxParse-li">
681 |                 <view class="wxParse-li-inner">
682 |                     <view class="wxParse-li-text">
683 |                         <text class="wxParse-li-circle"></text>
684 |                     </view>
685 |                     <view class="wxParse-li-text">
686 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
687 |                             <template is="wxParse11" data="{{item}}"/>
688 |                         </block>
689 |                     </view>
690 |                 </view>
691 |             </view>
692 |         </block>
693 | 
694 |         <!--video类型-->
695 |         <block wx:elif="{{item.tag == 'video'}}">
696 | 
697 |             <view  class="wxParse-{{item.tag}}">
698 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
699 |             </view>
700 |             
701 |         </block>
702 |         <!--img类型-->
703 |         <block wx:elif="{{item.tag == 'img'}}">
704 |             <view class="wxParse-{{item.tag}}">                 
705 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
706 |             </view>
707 |         </block>
708 | 
709 |         <block wx:else>
710 |             <view  class="wxParse-{{item.tag}}">
711 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
712 |                     <template is="wxParse11" data="{{item}}"/>                 
713 |                 </block>
714 |             </view>
715 |         </block>
716 | 
717 | 
718 |     </block>
719 | 
720 |     <!--判断是否是文本节点-->
721 |     <block wx:elif="{{item.node == 'text'}}">
722 |         <!--如果是，直接进行-->
723 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
724 |             <text>{{item.text}}</text>
725 |         </block>
726 |     </block>
727 | 
728 | </template>
729 | 
730 | 
731 | <template name="wxParse11">
732 |     <!--<template is="wxParse1" data="{{item}}" />-->
733 |     <!--判断是否是标签节点-->
734 |     <block wx:if="{{item.node == 'element'}}">
735 |         
736 |         <block wx:if="{{item.tag == 'button'}}">
737 |             <button type="default" size="mini" >
738 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
739 |                     <template is="wxParse12" data="{{item}}"/>
740 |                 </block>
741 |              </button>
742 |         </block>
743 |         <!--img类型-->
744 |         <block wx:elif="{{item.tag == 'li'}}">
745 |             <view class="wxParse-li">
746 |                 <view class="wxParse-li-inner">
747 |                     <view class="wxParse-li-text">
748 |                         <text class="wxParse-li-circle"></text>
749 |                     </view>
750 |                     <view class="wxParse-li-text">
751 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
752 |                             <template is="wxParse12" data="{{item}}"/>
753 |                         </block>
754 |                     </view>
755 |                 </view>
756 |             </view>
757 |         </block>
758 | 
759 |         <!--video类型-->
760 |         <block wx:elif="{{item.tag == 'video'}}">
761 | 
762 |             <view  class="wxParse-{{item.tag}}">
763 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
764 |             </view>
765 |             
766 |         </block>
767 |         <!--img类型-->
768 |         <block wx:elif="{{item.tag == 'img'}}">
769 |             <view class="wxParse-{{item.tag}}">                 
770 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
771 |             </view>
772 |         </block>
773 | 
774 |         <block wx:else>
775 |             <view  class="wxParse-{{item.tag}}">
776 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
777 |                     <template is="wxParse12" data="{{item}}"/>                 
778 |                 </block>
779 |             </view>
780 |         </block>
781 | 
782 | 
783 |     </block>
784 | 
785 |     <!--判断是否是文本节点-->
786 |     <block wx:elif="{{item.node == 'text'}}">
787 |         <!--如果是，直接进行-->
788 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
789 |             <text>{{item.text}}</text>
790 |         </block>
791 |     </block>
792 | 
793 | </template>
794 | 
795 | <template name="wxParse12">
796 |     <!--<template is="wxParse1" data="{{item}}" />-->
797 |     <!--判断是否是标签节点-->
798 |     <block wx:if="{{item.node == 'element'}}">
799 |         
800 |         <block wx:if="{{item.tag == 'button'}}">
801 |             <button type="default" size="mini" >
802 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
803 |                     <template is="wxParse13" data="{{item}}"/>
804 |                 </block>
805 |              </button>
806 |         </block>
807 |         <!--img类型-->
808 |         <block wx:elif="{{item.tag == 'li'}}">
809 |             <view class="wxParse-li">
810 |                 <view class="wxParse-li-inner">
811 |                     <view class="wxParse-li-text">
812 |                         <text class="wxParse-li-circle"></text>
813 |                     </view>
814 |                     <view class="wxParse-li-text">
815 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
816 |                             <template is="wxParse13" data="{{item}}"/>
817 |                         </block>
818 |                     </view>
819 |                 </view>
820 |             </view>
821 |         </block>
822 | 
823 |         <!--video类型-->
824 |         <block wx:elif="{{item.tag == 'video'}}">
825 | 
826 |             <view  class="wxParse-{{item.tag}}">
827 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
828 |             </view>
829 |             
830 |         </block>
831 |         <!--img类型-->
832 |         <block wx:elif="{{item.tag == 'img'}}">
833 |             <view class="wxParse-{{item.tag}}">                 
834 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
835 |             </view>
836 |         </block>
837 | 
838 |         <block wx:else>
839 |             <view  class="wxParse-{{item.tag}}">
840 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
841 |                     <template is="wxParse13" data="{{item}}"/>                 
842 |                 </block>
843 |             </view>
844 |         </block>
845 | 
846 | 
847 |     </block>
848 | 
849 |     <!--判断是否是文本节点-->
850 |     <block wx:elif="{{item.node == 'text'}}">
851 |         <!--如果是，直接进行-->
852 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
853 |             <text>{{item.text}}</text>
854 |         </block>
855 |     </block>
856 | 
857 | </template>
858 | 
859 | 
860 | <template name="wxParse13">
861 |     <!--<template is="wxParse1" data="{{item}}" />-->
862 |     <!--判断是否是标签节点-->
863 |     <block wx:if="{{item.node == 'element'}}">
864 |         
865 |         <block wx:if="{{item.tag == 'button'}}">
866 |             <button type="default" size="mini" >
867 |                 <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
868 |                     <template is="wxParse14" data="{{item}}"/>
869 |                 </block>
870 |              </button>
871 |         </block>
872 |         <!--img类型-->
873 |         <block wx:elif="{{item.tag == 'li'}}">
874 |             <view class="wxParse-li">
875 |                 <view class="wxParse-li-inner">
876 |                     <view class="wxParse-li-text">
877 |                         <text class="wxParse-li-circle"></text>
878 |                     </view>
879 |                     <view class="wxParse-li-text">
880 |                         <block wx:for="{{item.child}}" wx:for-item="item" wx:key="">
881 |                             <template is="wxParse14" data="{{item}}"/>
882 |                         </block>
883 |                     </view>
884 |                 </view>
885 |             </view>
886 |         </block>
887 | 
888 |         <!--video类型-->
889 |         <block wx:elif="{{item.tag == 'video'}}">
890 | 
891 |             <view  class="wxParse-{{item.tag}}">
892 |                 <video class="wxParse-{{item.tag}}-video" src="{{item.attr.src}}"></video>
893 |             </view>
894 |             
895 |         </block>
896 |         <!--img类型-->
897 |         <block wx:elif="{{item.tag == 'img'}}">
898 |             <view class="wxParse-{{item.tag}}">                 
899 |                 <image src="{{item.attr.src}}" mode="aspectFit"></image>             
900 |             </view>
901 |         </block>
902 | 
903 |         <block wx:else>
904 |             <view  class="wxParse-{{item.tag}}">
905 |                 <block  wx:for="{{item.child}}" wx:for-item="item" wx:key="">       
906 |                     <template is="wxParse14" data="{{item}}"/>                 
907 |                 </block>
908 |             </view>
909 |         </block>
910 | 
911 | 
912 |     </block>
913 | 
914 |     <!--判断是否是文本节点-->
915 |     <block wx:elif="{{item.node == 'text'}}">
916 |         <!--如果是，直接进行-->
917 |         <block wx:if="{{item.text != '' || item.text != ' ' || item.text != '  '}}">
918 |             <text>{{item.text}}</text>
919 |         </block>
920 |     </block>
921 | 
922 | </template>
923 | 


--------------------------------------------------------------------------------
/wxParse/showdown.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * author: Di (微信小程序开发工程师)
   3 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
   4 |  *               垂直微信小程序开发交流社区
   5 |  * 
   6 |  * github地址: https://github.com/icindy/wxParse
   7 |  * 
   8 |  * for: 微信小程序富文本解析
   9 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
  10 |  */
  11 | ;/*! showdown 19-08-2016 */
  12 | (function(){
  13 | /**
  14 |  * Created by Tivie on 13-07-2015.
  15 |  */
  16 | 
  17 | function getDefaultOpts(simple) {
  18 |   'use strict';
  19 | 
  20 |   var defaultOptions = {
  21 |     omitExtraWLInCodeBlocks: {
  22 |       defaultValue: false,
  23 |       describe: 'Omit the default extra whiteline added to code blocks',
  24 |       type: 'boolean'
  25 |     },
  26 |     noHeaderId: {
  27 |       defaultValue: false,
  28 |       describe: 'Turn on/off generated header id',
  29 |       type: 'boolean'
  30 |     },
  31 |     prefixHeaderId: {
  32 |       defaultValue: false,
  33 |       describe: 'Specify a prefix to generated header ids',
  34 |       type: 'string'
  35 |     },
  36 |     headerLevelStart: {
  37 |       defaultValue: false,
  38 |       describe: 'The header blocks level start',
  39 |       type: 'integer'
  40 |     },
  41 |     parseImgDimensions: {
  42 |       defaultValue: false,
  43 |       describe: 'Turn on/off image dimension parsing',
  44 |       type: 'boolean'
  45 |     },
  46 |     simplifiedAutoLink: {
  47 |       defaultValue: false,
  48 |       describe: 'Turn on/off GFM autolink style',
  49 |       type: 'boolean'
  50 |     },
  51 |     literalMidWordUnderscores: {
  52 |       defaultValue: false,
  53 |       describe: 'Parse midword underscores as literal underscores',
  54 |       type: 'boolean'
  55 |     },
  56 |     strikethrough: {
  57 |       defaultValue: false,
  58 |       describe: 'Turn on/off strikethrough support',
  59 |       type: 'boolean'
  60 |     },
  61 |     tables: {
  62 |       defaultValue: false,
  63 |       describe: 'Turn on/off tables support',
  64 |       type: 'boolean'
  65 |     },
  66 |     tablesHeaderId: {
  67 |       defaultValue: false,
  68 |       describe: 'Add an id to table headers',
  69 |       type: 'boolean'
  70 |     },
  71 |     ghCodeBlocks: {
  72 |       defaultValue: true,
  73 |       describe: 'Turn on/off GFM fenced code blocks support',
  74 |       type: 'boolean'
  75 |     },
  76 |     tasklists: {
  77 |       defaultValue: false,
  78 |       describe: 'Turn on/off GFM tasklist support',
  79 |       type: 'boolean'
  80 |     },
  81 |     smoothLivePreview: {
  82 |       defaultValue: false,
  83 |       describe: 'Prevents weird effects in live previews due to incomplete input',
  84 |       type: 'boolean'
  85 |     },
  86 |     smartIndentationFix: {
  87 |       defaultValue: false,
  88 |       description: 'Tries to smartly fix identation in es6 strings',
  89 |       type: 'boolean'
  90 |     }
  91 |   };
  92 |   if (simple === false) {
  93 |     return JSON.parse(JSON.stringify(defaultOptions));
  94 |   }
  95 |   var ret = {};
  96 |   for (var opt in defaultOptions) {
  97 |     if (defaultOptions.hasOwnProperty(opt)) {
  98 |       ret[opt] = defaultOptions[opt].defaultValue;
  99 |     }
 100 |   }
 101 |   return ret;
 102 | }
 103 | 
 104 | /**
 105 |  * Created by Tivie on 06-01-2015.
 106 |  */
 107 | 
 108 | // Private properties
 109 | var showdown = {},
 110 |     parsers = {},
 111 |     extensions = {},
 112 |     globalOptions = getDefaultOpts(true),
 113 |     flavor = {
 114 |       github: {
 115 |         omitExtraWLInCodeBlocks:   true,
 116 |         prefixHeaderId:            'user-content-',
 117 |         simplifiedAutoLink:        true,
 118 |         literalMidWordUnderscores: true,
 119 |         strikethrough:             true,
 120 |         tables:                    true,
 121 |         tablesHeaderId:            true,
 122 |         ghCodeBlocks:              true,
 123 |         tasklists:                 true
 124 |       },
 125 |       vanilla: getDefaultOpts(true)
 126 |     };
 127 | 
 128 | /**
 129 |  * helper namespace
 130 |  * @type {{}}
 131 |  */
 132 | showdown.helper = {};
 133 | 
 134 | /**
 135 |  * TODO LEGACY SUPPORT CODE
 136 |  * @type {{}}
 137 |  */
 138 | showdown.extensions = {};
 139 | 
 140 | /**
 141 |  * Set a global option
 142 |  * @static
 143 |  * @param {string} key
 144 |  * @param {*} value
 145 |  * @returns {showdown}
 146 |  */
 147 | showdown.setOption = function (key, value) {
 148 |   'use strict';
 149 |   globalOptions[key] = value;
 150 |   return this;
 151 | };
 152 | 
 153 | /**
 154 |  * Get a global option
 155 |  * @static
 156 |  * @param {string} key
 157 |  * @returns {*}
 158 |  */
 159 | showdown.getOption = function (key) {
 160 |   'use strict';
 161 |   return globalOptions[key];
 162 | };
 163 | 
 164 | /**
 165 |  * Get the global options
 166 |  * @static
 167 |  * @returns {{}}
 168 |  */
 169 | showdown.getOptions = function () {
 170 |   'use strict';
 171 |   return globalOptions;
 172 | };
 173 | 
 174 | /**
 175 |  * Reset global options to the default values
 176 |  * @static
 177 |  */
 178 | showdown.resetOptions = function () {
 179 |   'use strict';
 180 |   globalOptions = getDefaultOpts(true);
 181 | };
 182 | 
 183 | /**
 184 |  * Set the flavor showdown should use as default
 185 |  * @param {string} name
 186 |  */
 187 | showdown.setFlavor = function (name) {
 188 |   'use strict';
 189 |   if (flavor.hasOwnProperty(name)) {
 190 |     var preset = flavor[name];
 191 |     for (var option in preset) {
 192 |       if (preset.hasOwnProperty(option)) {
 193 |         globalOptions[option] = preset[option];
 194 |       }
 195 |     }
 196 |   }
 197 | };
 198 | 
 199 | /**
 200 |  * Get the default options
 201 |  * @static
 202 |  * @param {boolean} [simple=true]
 203 |  * @returns {{}}
 204 |  */
 205 | showdown.getDefaultOptions = function (simple) {
 206 |   'use strict';
 207 |   return getDefaultOpts(simple);
 208 | };
 209 | 
 210 | /**
 211 |  * Get or set a subParser
 212 |  *
 213 |  * subParser(name)       - Get a registered subParser
 214 |  * subParser(name, func) - Register a subParser
 215 |  * @static
 216 |  * @param {string} name
 217 |  * @param {function} [func]
 218 |  * @returns {*}
 219 |  */
 220 | showdown.subParser = function (name, func) {
 221 |   'use strict';
 222 |   if (showdown.helper.isString(name)) {
 223 |     if (typeof func !== 'undefined') {
 224 |       parsers[name] = func;
 225 |     } else {
 226 |       if (parsers.hasOwnProperty(name)) {
 227 |         return parsers[name];
 228 |       } else {
 229 |         throw Error('SubParser named ' + name + ' not registered!');
 230 |       }
 231 |     }
 232 |   }
 233 | };
 234 | 
 235 | /**
 236 |  * Gets or registers an extension
 237 |  * @static
 238 |  * @param {string} name
 239 |  * @param {object|function=} ext
 240 |  * @returns {*}
 241 |  */
 242 | showdown.extension = function (name, ext) {
 243 |   'use strict';
 244 | 
 245 |   if (!showdown.helper.isString(name)) {
 246 |     throw Error('Extension \'name\' must be a string');
 247 |   }
 248 | 
 249 |   name = showdown.helper.stdExtName(name);
 250 | 
 251 |   // Getter
 252 |   if (showdown.helper.isUndefined(ext)) {
 253 |     if (!extensions.hasOwnProperty(name)) {
 254 |       throw Error('Extension named ' + name + ' is not registered!');
 255 |     }
 256 |     return extensions[name];
 257 | 
 258 |     // Setter
 259 |   } else {
 260 |     // Expand extension if it's wrapped in a function
 261 |     if (typeof ext === 'function') {
 262 |       ext = ext();
 263 |     }
 264 | 
 265 |     // Ensure extension is an array
 266 |     if (!showdown.helper.isArray(ext)) {
 267 |       ext = [ext];
 268 |     }
 269 | 
 270 |     var validExtension = validate(ext, name);
 271 | 
 272 |     if (validExtension.valid) {
 273 |       extensions[name] = ext;
 274 |     } else {
 275 |       throw Error(validExtension.error);
 276 |     }
 277 |   }
 278 | };
 279 | 
 280 | /**
 281 |  * Gets all extensions registered
 282 |  * @returns {{}}
 283 |  */
 284 | showdown.getAllExtensions = function () {
 285 |   'use strict';
 286 |   return extensions;
 287 | };
 288 | 
 289 | /**
 290 |  * Remove an extension
 291 |  * @param {string} name
 292 |  */
 293 | showdown.removeExtension = function (name) {
 294 |   'use strict';
 295 |   delete extensions[name];
 296 | };
 297 | 
 298 | /**
 299 |  * Removes all extensions
 300 |  */
 301 | showdown.resetExtensions = function () {
 302 |   'use strict';
 303 |   extensions = {};
 304 | };
 305 | 
 306 | /**
 307 |  * Validate extension
 308 |  * @param {array} extension
 309 |  * @param {string} name
 310 |  * @returns {{valid: boolean, error: string}}
 311 |  */
 312 | function validate(extension, name) {
 313 |   'use strict';
 314 | 
 315 |   var errMsg = (name) ? 'Error in ' + name + ' extension->' : 'Error in unnamed extension',
 316 |     ret = {
 317 |       valid: true,
 318 |       error: ''
 319 |     };
 320 | 
 321 |   if (!showdown.helper.isArray(extension)) {
 322 |     extension = [extension];
 323 |   }
 324 | 
 325 |   for (var i = 0; i < extension.length; ++i) {
 326 |     var baseMsg = errMsg + ' sub-extension ' + i + ': ',
 327 |         ext = extension[i];
 328 |     if (typeof ext !== 'object') {
 329 |       ret.valid = false;
 330 |       ret.error = baseMsg + 'must be an object, but ' + typeof ext + ' given';
 331 |       return ret;
 332 |     }
 333 | 
 334 |     if (!showdown.helper.isString(ext.type)) {
 335 |       ret.valid = false;
 336 |       ret.error = baseMsg + 'property "type" must be a string, but ' + typeof ext.type + ' given';
 337 |       return ret;
 338 |     }
 339 | 
 340 |     var type = ext.type = ext.type.toLowerCase();
 341 | 
 342 |     // normalize extension type
 343 |     if (type === 'language') {
 344 |       type = ext.type = 'lang';
 345 |     }
 346 | 
 347 |     if (type === 'html') {
 348 |       type = ext.type = 'output';
 349 |     }
 350 | 
 351 |     if (type !== 'lang' && type !== 'output' && type !== 'listener') {
 352 |       ret.valid = false;
 353 |       ret.error = baseMsg + 'type ' + type + ' is not recognized. Valid values: "lang/language", "output/html" or "listener"';
 354 |       return ret;
 355 |     }
 356 | 
 357 |     if (type === 'listener') {
 358 |       if (showdown.helper.isUndefined(ext.listeners)) {
 359 |         ret.valid = false;
 360 |         ret.error = baseMsg + '. Extensions of type "listener" must have a property called "listeners"';
 361 |         return ret;
 362 |       }
 363 |     } else {
 364 |       if (showdown.helper.isUndefined(ext.filter) && showdown.helper.isUndefined(ext.regex)) {
 365 |         ret.valid = false;
 366 |         ret.error = baseMsg + type + ' extensions must define either a "regex" property or a "filter" method';
 367 |         return ret;
 368 |       }
 369 |     }
 370 | 
 371 |     if (ext.listeners) {
 372 |       if (typeof ext.listeners !== 'object') {
 373 |         ret.valid = false;
 374 |         ret.error = baseMsg + '"listeners" property must be an object but ' + typeof ext.listeners + ' given';
 375 |         return ret;
 376 |       }
 377 |       for (var ln in ext.listeners) {
 378 |         if (ext.listeners.hasOwnProperty(ln)) {
 379 |           if (typeof ext.listeners[ln] !== 'function') {
 380 |             ret.valid = false;
 381 |             ret.error = baseMsg + '"listeners" property must be an hash of [event name]: [callback]. listeners.' + ln +
 382 |               ' must be a function but ' + typeof ext.listeners[ln] + ' given';
 383 |             return ret;
 384 |           }
 385 |         }
 386 |       }
 387 |     }
 388 | 
 389 |     if (ext.filter) {
 390 |       if (typeof ext.filter !== 'function') {
 391 |         ret.valid = false;
 392 |         ret.error = baseMsg + '"filter" must be a function, but ' + typeof ext.filter + ' given';
 393 |         return ret;
 394 |       }
 395 |     } else if (ext.regex) {
 396 |       if (showdown.helper.isString(ext.regex)) {
 397 |         ext.regex = new RegExp(ext.regex, 'g');
 398 |       }
 399 |       if (!ext.regex instanceof RegExp) {
 400 |         ret.valid = false;
 401 |         ret.error = baseMsg + '"regex" property must either be a string or a RegExp object, but ' + typeof ext.regex + ' given';
 402 |         return ret;
 403 |       }
 404 |       if (showdown.helper.isUndefined(ext.replace)) {
 405 |         ret.valid = false;
 406 |         ret.error = baseMsg + '"regex" extensions must implement a replace string or function';
 407 |         return ret;
 408 |       }
 409 |     }
 410 |   }
 411 |   return ret;
 412 | }
 413 | 
 414 | /**
 415 |  * Validate extension
 416 |  * @param {object} ext
 417 |  * @returns {boolean}
 418 |  */
 419 | showdown.validateExtension = function (ext) {
 420 |   'use strict';
 421 | 
 422 |   var validateExtension = validate(ext, null);
 423 |   if (!validateExtension.valid) {
 424 |     console.warn(validateExtension.error);
 425 |     return false;
 426 |   }
 427 |   return true;
 428 | };
 429 | 
 430 | /**
 431 |  * showdownjs helper functions
 432 |  */
 433 | 
 434 | if (!showdown.hasOwnProperty('helper')) {
 435 |   showdown.helper = {};
 436 | }
 437 | 
 438 | /**
 439 |  * Check if var is string
 440 |  * @static
 441 |  * @param {string} a
 442 |  * @returns {boolean}
 443 |  */
 444 | showdown.helper.isString = function isString(a) {
 445 |   'use strict';
 446 |   return (typeof a === 'string' || a instanceof String);
 447 | };
 448 | 
 449 | /**
 450 |  * Check if var is a function
 451 |  * @static
 452 |  * @param {string} a
 453 |  * @returns {boolean}
 454 |  */
 455 | showdown.helper.isFunction = function isFunction(a) {
 456 |   'use strict';
 457 |   var getType = {};
 458 |   return a && getType.toString.call(a) === '[object Function]';
 459 | };
 460 | 
 461 | /**
 462 |  * ForEach helper function
 463 |  * @static
 464 |  * @param {*} obj
 465 |  * @param {function} callback
 466 |  */
 467 | showdown.helper.forEach = function forEach(obj, callback) {
 468 |   'use strict';
 469 |   if (typeof obj.forEach === 'function') {
 470 |     obj.forEach(callback);
 471 |   } else {
 472 |     for (var i = 0; i < obj.length; i++) {
 473 |       callback(obj[i], i, obj);
 474 |     }
 475 |   }
 476 | };
 477 | 
 478 | /**
 479 |  * isArray helper function
 480 |  * @static
 481 |  * @param {*} a
 482 |  * @returns {boolean}
 483 |  */
 484 | showdown.helper.isArray = function isArray(a) {
 485 |   'use strict';
 486 |   return a.constructor === Array;
 487 | };
 488 | 
 489 | /**
 490 |  * Check if value is undefined
 491 |  * @static
 492 |  * @param {*} value The value to check.
 493 |  * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
 494 |  */
 495 | showdown.helper.isUndefined = function isUndefined(value) {
 496 |   'use strict';
 497 |   return typeof value === 'undefined';
 498 | };
 499 | 
 500 | /**
 501 |  * Standardidize extension name
 502 |  * @static
 503 |  * @param {string} s extension name
 504 |  * @returns {string}
 505 |  */
 506 | showdown.helper.stdExtName = function (s) {
 507 |   'use strict';
 508 |   return s.replace(/[_-]||\s/g, '').toLowerCase();
 509 | };
 510 | 
 511 | function escapeCharactersCallback(wholeMatch, m1) {
 512 |   'use strict';
 513 |   var charCodeToEscape = m1.charCodeAt(0);
 514 |   return '~E' + charCodeToEscape + 'E';
 515 | }
 516 | 
 517 | /**
 518 |  * Callback used to escape characters when passing through String.replace
 519 |  * @static
 520 |  * @param {string} wholeMatch
 521 |  * @param {string} m1
 522 |  * @returns {string}
 523 |  */
 524 | showdown.helper.escapeCharactersCallback = escapeCharactersCallback;
 525 | 
 526 | /**
 527 |  * Escape characters in a string
 528 |  * @static
 529 |  * @param {string} text
 530 |  * @param {string} charsToEscape
 531 |  * @param {boolean} afterBackslash
 532 |  * @returns {XML|string|void|*}
 533 |  */
 534 | showdown.helper.escapeCharacters = function escapeCharacters(text, charsToEscape, afterBackslash) {
 535 |   'use strict';
 536 |   // First we have to escape the escape characters so that
 537 |   // we can build a character class out of them
 538 |   var regexString = '([' + charsToEscape.replace(/([\[\]\\])/g, '\\$1') + '])';
 539 | 
 540 |   if (afterBackslash) {
 541 |     regexString = '\\\\' + regexString;
 542 |   }
 543 | 
 544 |   var regex = new RegExp(regexString, 'g');
 545 |   text = text.replace(regex, escapeCharactersCallback);
 546 | 
 547 |   return text;
 548 | };
 549 | 
 550 | var rgxFindMatchPos = function (str, left, right, flags) {
 551 |   'use strict';
 552 |   var f = flags || '',
 553 |     g = f.indexOf('g') > -1,
 554 |     x = new RegExp(left + '|' + right, 'g' + f.replace(/g/g, '')),
 555 |     l = new RegExp(left, f.replace(/g/g, '')),
 556 |     pos = [],
 557 |     t, s, m, start, end;
 558 | 
 559 |   do {
 560 |     t = 0;
 561 |     while ((m = x.exec(str))) {
 562 |       if (l.test(m[0])) {
 563 |         if (!(t++)) {
 564 |           s = x.lastIndex;
 565 |           start = s - m[0].length;
 566 |         }
 567 |       } else if (t) {
 568 |         if (!--t) {
 569 |           end = m.index + m[0].length;
 570 |           var obj = {
 571 |             left: {start: start, end: s},
 572 |             match: {start: s, end: m.index},
 573 |             right: {start: m.index, end: end},
 574 |             wholeMatch: {start: start, end: end}
 575 |           };
 576 |           pos.push(obj);
 577 |           if (!g) {
 578 |             return pos;
 579 |           }
 580 |         }
 581 |       }
 582 |     }
 583 |   } while (t && (x.lastIndex = s));
 584 | 
 585 |   return pos;
 586 | };
 587 | 
 588 | /**
 589 |  * matchRecursiveRegExp
 590 |  *
 591 |  * (c) 2007 Steven Levithan <stevenlevithan.com>
 592 |  * MIT License
 593 |  *
 594 |  * Accepts a string to search, a left and right format delimiter
 595 |  * as regex patterns, and optional regex flags. Returns an array
 596 |  * of matches, allowing nested instances of left/right delimiters.
 597 |  * Use the "g" flag to return all matches, otherwise only the
 598 |  * first is returned. Be careful to ensure that the left and
 599 |  * right format delimiters produce mutually exclusive matches.
 600 |  * Backreferences are not supported within the right delimiter
 601 |  * due to how it is internally combined with the left delimiter.
 602 |  * When matching strings whose format delimiters are unbalanced
 603 |  * to the left or right, the output is intentionally as a
 604 |  * conventional regex library with recursion support would
 605 |  * produce, e.g. "<<x>" and "<x>>" both produce ["x"] when using
 606 |  * "<" and ">" as the delimiters (both strings contain a single,
 607 |  * balanced instance of "<x>").
 608 |  *
 609 |  * examples:
 610 |  * matchRecursiveRegExp("test", "\\(", "\\)")
 611 |  * returns: []
 612 |  * matchRecursiveRegExp("<t<<e>><s>>t<>", "<", ">", "g")
 613 |  * returns: ["t<<e>><s>", ""]
 614 |  * matchRecursiveRegExp("<div id=\"x\">test</div>", "<div\\b[^>]*>", "</div>", "gi")
 615 |  * returns: ["test"]
 616 |  */
 617 | showdown.helper.matchRecursiveRegExp = function (str, left, right, flags) {
 618 |   'use strict';
 619 | 
 620 |   var matchPos = rgxFindMatchPos (str, left, right, flags),
 621 |     results = [];
 622 | 
 623 |   for (var i = 0; i < matchPos.length; ++i) {
 624 |     results.push([
 625 |       str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
 626 |       str.slice(matchPos[i].match.start, matchPos[i].match.end),
 627 |       str.slice(matchPos[i].left.start, matchPos[i].left.end),
 628 |       str.slice(matchPos[i].right.start, matchPos[i].right.end)
 629 |     ]);
 630 |   }
 631 |   return results;
 632 | };
 633 | 
 634 | /**
 635 |  *
 636 |  * @param {string} str
 637 |  * @param {string|function} replacement
 638 |  * @param {string} left
 639 |  * @param {string} right
 640 |  * @param {string} flags
 641 |  * @returns {string}
 642 |  */
 643 | showdown.helper.replaceRecursiveRegExp = function (str, replacement, left, right, flags) {
 644 |   'use strict';
 645 | 
 646 |   if (!showdown.helper.isFunction(replacement)) {
 647 |     var repStr = replacement;
 648 |     replacement = function () {
 649 |       return repStr;
 650 |     };
 651 |   }
 652 | 
 653 |   var matchPos = rgxFindMatchPos(str, left, right, flags),
 654 |       finalStr = str,
 655 |       lng = matchPos.length;
 656 | 
 657 |   if (lng > 0) {
 658 |     var bits = [];
 659 |     if (matchPos[0].wholeMatch.start !== 0) {
 660 |       bits.push(str.slice(0, matchPos[0].wholeMatch.start));
 661 |     }
 662 |     for (var i = 0; i < lng; ++i) {
 663 |       bits.push(
 664 |         replacement(
 665 |           str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
 666 |           str.slice(matchPos[i].match.start, matchPos[i].match.end),
 667 |           str.slice(matchPos[i].left.start, matchPos[i].left.end),
 668 |           str.slice(matchPos[i].right.start, matchPos[i].right.end)
 669 |         )
 670 |       );
 671 |       if (i < lng - 1) {
 672 |         bits.push(str.slice(matchPos[i].wholeMatch.end, matchPos[i + 1].wholeMatch.start));
 673 |       }
 674 |     }
 675 |     if (matchPos[lng - 1].wholeMatch.end < str.length) {
 676 |       bits.push(str.slice(matchPos[lng - 1].wholeMatch.end));
 677 |     }
 678 |     finalStr = bits.join('');
 679 |   }
 680 |   return finalStr;
 681 | };
 682 | 
 683 | /**
 684 |  * POLYFILLS
 685 |  */
 686 | if (showdown.helper.isUndefined(console)) {
 687 |   console = {
 688 |     warn: function (msg) {
 689 |       'use strict';
 690 |       alert(msg);
 691 |     },
 692 |     log: function (msg) {
 693 |       'use strict';
 694 |       alert(msg);
 695 |     },
 696 |     error: function (msg) {
 697 |       'use strict';
 698 |       throw msg;
 699 |     }
 700 |   };
 701 | }
 702 | 
 703 | /**
 704 |  * Created by Estevao on 31-05-2015.
 705 |  */
 706 | 
 707 | /**
 708 |  * Showdown Converter class
 709 |  * @class
 710 |  * @param {object} [converterOptions]
 711 |  * @returns {Converter}
 712 |  */
 713 | showdown.Converter = function (converterOptions) {
 714 |   'use strict';
 715 | 
 716 |   var
 717 |       /**
 718 |        * Options used by this converter
 719 |        * @private
 720 |        * @type {{}}
 721 |        */
 722 |       options = {},
 723 | 
 724 |       /**
 725 |        * Language extensions used by this converter
 726 |        * @private
 727 |        * @type {Array}
 728 |        */
 729 |       langExtensions = [],
 730 | 
 731 |       /**
 732 |        * Output modifiers extensions used by this converter
 733 |        * @private
 734 |        * @type {Array}
 735 |        */
 736 |       outputModifiers = [],
 737 | 
 738 |       /**
 739 |        * Event listeners
 740 |        * @private
 741 |        * @type {{}}
 742 |        */
 743 |       listeners = {};
 744 | 
 745 |   _constructor();
 746 | 
 747 |   /**
 748 |    * Converter constructor
 749 |    * @private
 750 |    */
 751 |   function _constructor() {
 752 |     converterOptions = converterOptions || {};
 753 | 
 754 |     for (var gOpt in globalOptions) {
 755 |       if (globalOptions.hasOwnProperty(gOpt)) {
 756 |         options[gOpt] = globalOptions[gOpt];
 757 |       }
 758 |     }
 759 | 
 760 |     // Merge options
 761 |     if (typeof converterOptions === 'object') {
 762 |       for (var opt in converterOptions) {
 763 |         if (converterOptions.hasOwnProperty(opt)) {
 764 |           options[opt] = converterOptions[opt];
 765 |         }
 766 |       }
 767 |     } else {
 768 |       throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions +
 769 |       ' was passed instead.');
 770 |     }
 771 | 
 772 |     if (options.extensions) {
 773 |       showdown.helper.forEach(options.extensions, _parseExtension);
 774 |     }
 775 |   }
 776 | 
 777 |   /**
 778 |    * Parse extension
 779 |    * @param {*} ext
 780 |    * @param {string} [name='']
 781 |    * @private
 782 |    */
 783 |   function _parseExtension(ext, name) {
 784 | 
 785 |     name = name || null;
 786 |     // If it's a string, the extension was previously loaded
 787 |     if (showdown.helper.isString(ext)) {
 788 |       ext = showdown.helper.stdExtName(ext);
 789 |       name = ext;
 790 | 
 791 |       // LEGACY_SUPPORT CODE
 792 |       if (showdown.extensions[ext]) {
 793 |         console.warn('DEPRECATION WARNING: ' + ext + ' is an old extension that uses a deprecated loading method.' +
 794 |           'Please inform the developer that the extension should be updated!');
 795 |         legacyExtensionLoading(showdown.extensions[ext], ext);
 796 |         return;
 797 |       // END LEGACY SUPPORT CODE
 798 | 
 799 |       } else if (!showdown.helper.isUndefined(extensions[ext])) {
 800 |         ext = extensions[ext];
 801 | 
 802 |       } else {
 803 |         throw Error('Extension "' + ext + '" could not be loaded. It was either not found or is not a valid extension.');
 804 |       }
 805 |     }
 806 | 
 807 |     if (typeof ext === 'function') {
 808 |       ext = ext();
 809 |     }
 810 | 
 811 |     if (!showdown.helper.isArray(ext)) {
 812 |       ext = [ext];
 813 |     }
 814 | 
 815 |     var validExt = validate(ext, name);
 816 |     if (!validExt.valid) {
 817 |       throw Error(validExt.error);
 818 |     }
 819 | 
 820 |     for (var i = 0; i < ext.length; ++i) {
 821 |       switch (ext[i].type) {
 822 | 
 823 |         case 'lang':
 824 |           langExtensions.push(ext[i]);
 825 |           break;
 826 | 
 827 |         case 'output':
 828 |           outputModifiers.push(ext[i]);
 829 |           break;
 830 |       }
 831 |       if (ext[i].hasOwnProperty(listeners)) {
 832 |         for (var ln in ext[i].listeners) {
 833 |           if (ext[i].listeners.hasOwnProperty(ln)) {
 834 |             listen(ln, ext[i].listeners[ln]);
 835 |           }
 836 |         }
 837 |       }
 838 |     }
 839 | 
 840 |   }
 841 | 
 842 |   /**
 843 |    * LEGACY_SUPPORT
 844 |    * @param {*} ext
 845 |    * @param {string} name
 846 |    */
 847 |   function legacyExtensionLoading(ext, name) {
 848 |     if (typeof ext === 'function') {
 849 |       ext = ext(new showdown.Converter());
 850 |     }
 851 |     if (!showdown.helper.isArray(ext)) {
 852 |       ext = [ext];
 853 |     }
 854 |     var valid = validate(ext, name);
 855 | 
 856 |     if (!valid.valid) {
 857 |       throw Error(valid.error);
 858 |     }
 859 | 
 860 |     for (var i = 0; i < ext.length; ++i) {
 861 |       switch (ext[i].type) {
 862 |         case 'lang':
 863 |           langExtensions.push(ext[i]);
 864 |           break;
 865 |         case 'output':
 866 |           outputModifiers.push(ext[i]);
 867 |           break;
 868 |         default:// should never reach here
 869 |           throw Error('Extension loader error: Type unrecognized!!!');
 870 |       }
 871 |     }
 872 |   }
 873 | 
 874 |   /**
 875 |    * Listen to an event
 876 |    * @param {string} name
 877 |    * @param {function} callback
 878 |    */
 879 |   function listen(name, callback) {
 880 |     if (!showdown.helper.isString(name)) {
 881 |       throw Error('Invalid argument in converter.listen() method: name must be a string, but ' + typeof name + ' given');
 882 |     }
 883 | 
 884 |     if (typeof callback !== 'function') {
 885 |       throw Error('Invalid argument in converter.listen() method: callback must be a function, but ' + typeof callback + ' given');
 886 |     }
 887 | 
 888 |     if (!listeners.hasOwnProperty(name)) {
 889 |       listeners[name] = [];
 890 |     }
 891 |     listeners[name].push(callback);
 892 |   }
 893 | 
 894 |   function rTrimInputText(text) {
 895 |     var rsp = text.match(/^\s*/)[0].length,
 896 |         rgx = new RegExp('^\\s{0,' + rsp + '}', 'gm');
 897 |     return text.replace(rgx, '');
 898 |   }
 899 | 
 900 |   /**
 901 |    * Dispatch an event
 902 |    * @private
 903 |    * @param {string} evtName Event name
 904 |    * @param {string} text Text
 905 |    * @param {{}} options Converter Options
 906 |    * @param {{}} globals
 907 |    * @returns {string}
 908 |    */
 909 |   this._dispatch = function dispatch (evtName, text, options, globals) {
 910 |     if (listeners.hasOwnProperty(evtName)) {
 911 |       for (var ei = 0; ei < listeners[evtName].length; ++ei) {
 912 |         var nText = listeners[evtName][ei](evtName, text, this, options, globals);
 913 |         if (nText && typeof nText !== 'undefined') {
 914 |           text = nText;
 915 |         }
 916 |       }
 917 |     }
 918 |     return text;
 919 |   };
 920 | 
 921 |   /**
 922 |    * Listen to an event
 923 |    * @param {string} name
 924 |    * @param {function} callback
 925 |    * @returns {showdown.Converter}
 926 |    */
 927 |   this.listen = function (name, callback) {
 928 |     listen(name, callback);
 929 |     return this;
 930 |   };
 931 | 
 932 |   /**
 933 |    * Converts a markdown string into HTML
 934 |    * @param {string} text
 935 |    * @returns {*}
 936 |    */
 937 |   this.makeHtml = function (text) {
 938 |     //check if text is not falsy
 939 |     if (!text) {
 940 |       return text;
 941 |     }
 942 | 
 943 |     var globals = {
 944 |       gHtmlBlocks:     [],
 945 |       gHtmlMdBlocks:   [],
 946 |       gHtmlSpans:      [],
 947 |       gUrls:           {},
 948 |       gTitles:         {},
 949 |       gDimensions:     {},
 950 |       gListLevel:      0,
 951 |       hashLinkCounts:  {},
 952 |       langExtensions:  langExtensions,
 953 |       outputModifiers: outputModifiers,
 954 |       converter:       this,
 955 |       ghCodeBlocks:    []
 956 |     };
 957 | 
 958 |     // attacklab: Replace ~ with ~T
 959 |     // This lets us use tilde as an escape char to avoid md5 hashes
 960 |     // The choice of character is arbitrary; anything that isn't
 961 |     // magic in Markdown will work.
 962 |     text = text.replace(/~/g, '~T');
 963 | 
 964 |     // attacklab: Replace $ with ~D
 965 |     // RegExp interprets $ as a special character
 966 |     // when it's in a replacement string
 967 |     text = text.replace(/\$/g, '~D');
 968 | 
 969 |     // Standardize line endings
 970 |     text = text.replace(/\r\n/g, '\n'); // DOS to Unix
 971 |     text = text.replace(/\r/g, '\n'); // Mac to Unix
 972 | 
 973 |     if (options.smartIndentationFix) {
 974 |       text = rTrimInputText(text);
 975 |     }
 976 | 
 977 |     // Make sure text begins and ends with a couple of newlines:
 978 |     //text = '\n\n' + text + '\n\n';
 979 |     text = text;
 980 |     // detab
 981 |     text = showdown.subParser('detab')(text, options, globals);
 982 | 
 983 |     // stripBlankLines
 984 |     text = showdown.subParser('stripBlankLines')(text, options, globals);
 985 | 
 986 |     //run languageExtensions
 987 |     showdown.helper.forEach(langExtensions, function (ext) {
 988 |       text = showdown.subParser('runExtension')(ext, text, options, globals);
 989 |     });
 990 | 
 991 |     // run the sub parsers
 992 |     text = showdown.subParser('hashPreCodeTags')(text, options, globals);
 993 |     text = showdown.subParser('githubCodeBlocks')(text, options, globals);
 994 |     text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
 995 |     text = showdown.subParser('hashHTMLSpans')(text, options, globals);
 996 |     text = showdown.subParser('stripLinkDefinitions')(text, options, globals);
 997 |     text = showdown.subParser('blockGamut')(text, options, globals);
 998 |     text = showdown.subParser('unhashHTMLSpans')(text, options, globals);
 999 |     text = showdown.subParser('unescapeSpecialChars')(text, options, globals);
1000 | 
1001 |     // attacklab: Restore dollar signs
1002 |     text = text.replace(/~D/g, '$$');
1003 | 
1004 |     // attacklab: Restore tildes
1005 |     text = text.replace(/~T/g, '~');
1006 | 
1007 |     // Run output modifiers
1008 |     showdown.helper.forEach(outputModifiers, function (ext) {
1009 |       text = showdown.subParser('runExtension')(ext, text, options, globals);
1010 |     });
1011 |     return text;
1012 |   };
1013 | 
1014 |   /**
1015 |    * Set an option of this Converter instance
1016 |    * @param {string} key
1017 |    * @param {*} value
1018 |    */
1019 |   this.setOption = function (key, value) {
1020 |     options[key] = value;
1021 |   };
1022 | 
1023 |   /**
1024 |    * Get the option of this Converter instance
1025 |    * @param {string} key
1026 |    * @returns {*}
1027 |    */
1028 |   this.getOption = function (key) {
1029 |     return options[key];
1030 |   };
1031 | 
1032 |   /**
1033 |    * Get the options of this Converter instance
1034 |    * @returns {{}}
1035 |    */
1036 |   this.getOptions = function () {
1037 |     return options;
1038 |   };
1039 | 
1040 |   /**
1041 |    * Add extension to THIS converter
1042 |    * @param {{}} extension
1043 |    * @param {string} [name=null]
1044 |    */
1045 |   this.addExtension = function (extension, name) {
1046 |     name = name || null;
1047 |     _parseExtension(extension, name);
1048 |   };
1049 | 
1050 |   /**
1051 |    * Use a global registered extension with THIS converter
1052 |    * @param {string} extensionName Name of the previously registered extension
1053 |    */
1054 |   this.useExtension = function (extensionName) {
1055 |     _parseExtension(extensionName);
1056 |   };
1057 | 
1058 |   /**
1059 |    * Set the flavor THIS converter should use
1060 |    * @param {string} name
1061 |    */
1062 |   this.setFlavor = function (name) {
1063 |     if (flavor.hasOwnProperty(name)) {
1064 |       var preset = flavor[name];
1065 |       for (var option in preset) {
1066 |         if (preset.hasOwnProperty(option)) {
1067 |           options[option] = preset[option];
1068 |         }
1069 |       }
1070 |     }
1071 |   };
1072 | 
1073 |   /**
1074 |    * Remove an extension from THIS converter.
1075 |    * Note: This is a costly operation. It's better to initialize a new converter
1076 |    * and specify the extensions you wish to use
1077 |    * @param {Array} extension
1078 |    */
1079 |   this.removeExtension = function (extension) {
1080 |     if (!showdown.helper.isArray(extension)) {
1081 |       extension = [extension];
1082 |     }
1083 |     for (var a = 0; a < extension.length; ++a) {
1084 |       var ext = extension[a];
1085 |       for (var i = 0; i < langExtensions.length; ++i) {
1086 |         if (langExtensions[i] === ext) {
1087 |           langExtensions[i].splice(i, 1);
1088 |         }
1089 |       }
1090 |       for (var ii = 0; ii < outputModifiers.length; ++i) {
1091 |         if (outputModifiers[ii] === ext) {
1092 |           outputModifiers[ii].splice(i, 1);
1093 |         }
1094 |       }
1095 |     }
1096 |   };
1097 | 
1098 |   /**
1099 |    * Get all extension of THIS converter
1100 |    * @returns {{language: Array, output: Array}}
1101 |    */
1102 |   this.getAllExtensions = function () {
1103 |     return {
1104 |       language: langExtensions,
1105 |       output: outputModifiers
1106 |     };
1107 |   };
1108 | };
1109 | 
1110 | /**
1111 |  * Turn Markdown link shortcuts into XHTML <a> tags.
1112 |  */
1113 | showdown.subParser('anchors', function (text, options, globals) {
1114 |   'use strict';
1115 | 
1116 |   text = globals.converter._dispatch('anchors.before', text, options, globals);
1117 | 
1118 |   var writeAnchorTag = function (wholeMatch, m1, m2, m3, m4, m5, m6, m7) {
1119 |     if (showdown.helper.isUndefined(m7)) {
1120 |       m7 = '';
1121 |     }
1122 |     wholeMatch = m1;
1123 |     var linkText = m2,
1124 |         linkId = m3.toLowerCase(),
1125 |         url = m4,
1126 |         title = m7;
1127 | 
1128 |     if (!url) {
1129 |       if (!linkId) {
1130 |         // lower-case and turn embedded newlines into spaces
1131 |         linkId = linkText.toLowerCase().replace(/ ?\n/g, ' ');
1132 |       }
1133 |       url = '#' + linkId;
1134 | 
1135 |       if (!showdown.helper.isUndefined(globals.gUrls[linkId])) {
1136 |         url = globals.gUrls[linkId];
1137 |         if (!showdown.helper.isUndefined(globals.gTitles[linkId])) {
1138 |           title = globals.gTitles[linkId];
1139 |         }
1140 |       } else {
1141 |         if (wholeMatch.search(/\(\s*\)$/m) > -1) {
1142 |           // Special case for explicit empty url
1143 |           url = '';
1144 |         } else {
1145 |           return wholeMatch;
1146 |         }
1147 |       }
1148 |     }
1149 | 
1150 |     url = showdown.helper.escapeCharacters(url, '*_', false);
1151 |     var result = '<a href="' + url + '"';
1152 | 
1153 |     if (title !== '' && title !== null) {
1154 |       title = title.replace(/"/g, '&quot;');
1155 |       title = showdown.helper.escapeCharacters(title, '*_', false);
1156 |       result += ' title="' + title + '"';
1157 |     }
1158 | 
1159 |     result += '>' + linkText + '</a>';
1160 | 
1161 |     return result;
1162 |   };
1163 | 
1164 |   // First, handle reference-style links: [link text] [id]
1165 |   /*
1166 |    text = text.replace(/
1167 |    (							// wrap whole match in $1
1168 |    \[
1169 |    (
1170 |    (?:
1171 |    \[[^\]]*\]		// allow brackets nested one level
1172 |    |
1173 |    [^\[]			// or anything else
1174 |    )*
1175 |    )
1176 |    \]
1177 | 
1178 |    [ ]?					// one optional space
1179 |    (?:\n[ ]*)?				// one optional newline followed by spaces
1180 | 
1181 |    \[
1182 |    (.*?)					// id = $3
1183 |    \]
1184 |    )()()()()					// pad remaining backreferences
1185 |    /g,_DoAnchors_callback);
1186 |    */
1187 |   text = text.replace(/(\[((?:\[[^\]]*]|[^\[\]])*)][ ]?(?:\n[ ]*)?\[(.*?)])()()()()/g, writeAnchorTag);
1188 | 
1189 |   //
1190 |   // Next, inline-style links: [link text](url "optional title")
1191 |   //
1192 | 
1193 |   /*
1194 |    text = text.replace(/
1195 |    (						// wrap whole match in $1
1196 |    \[
1197 |    (
1198 |    (?:
1199 |    \[[^\]]*\]	// allow brackets nested one level
1200 |    |
1201 |    [^\[\]]			// or anything else
1202 |    )
1203 |    )
1204 |    \]
1205 |    \(						// literal paren
1206 |    [ \t]*
1207 |    ()						// no id, so leave $3 empty
1208 |    <?(.*?)>?				// href = $4
1209 |    [ \t]*
1210 |    (						// $5
1211 |    (['"])				// quote char = $6
1212 |    (.*?)				// Title = $7
1213 |    \6					// matching quote
1214 |    [ \t]*				// ignore any spaces/tabs between closing quote and )
1215 |    )?						// title is optional
1216 |    \)
1217 |    )
1218 |    /g,writeAnchorTag);
1219 |    */
1220 |   text = text.replace(/(\[((?:\[[^\]]*]|[^\[\]])*)]\([ \t]*()<?(.*?(?:\(.*?\).*?)?)>?[ \t]*((['"])(.*?)\6[ \t]*)?\))/g,
1221 |                       writeAnchorTag);
1222 | 
1223 |   //
1224 |   // Last, handle reference-style shortcuts: [link text]
1225 |   // These must come last in case you've also got [link test][1]
1226 |   // or [link test](/foo)
1227 |   //
1228 | 
1229 |   /*
1230 |    text = text.replace(/
1231 |    (                // wrap whole match in $1
1232 |    \[
1233 |    ([^\[\]]+)       // link text = $2; can't contain '[' or ']'
1234 |    \]
1235 |    )()()()()()      // pad rest of backreferences
1236 |    /g, writeAnchorTag);
1237 |    */
1238 |   text = text.replace(/(\[([^\[\]]+)])()()()()()/g, writeAnchorTag);
1239 | 
1240 |   text = globals.converter._dispatch('anchors.after', text, options, globals);
1241 |   return text;
1242 | });
1243 | 
1244 | showdown.subParser('autoLinks', function (text, options, globals) {
1245 |   'use strict';
1246 | 
1247 |   text = globals.converter._dispatch('autoLinks.before', text, options, globals);
1248 | 
1249 |   var simpleURLRegex  = /\b(((https?|ftp|dict):\/\/|www\.)[^'">\s]+\.[^'">\s]+)(?=\s|$)(?!["<>])/gi,
1250 |       delimUrlRegex   = /<(((https?|ftp|dict):\/\/|www\.)[^'">\s]+)>/gi,
1251 |       simpleMailRegex = /(?:^|[ \n\t])([A-Za-z0-9!#$%&'*+-/=?^_`\{|}~\.]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)(?:$|[ \n\t])/gi,
1252 |       delimMailRegex  = /<(?:mailto:)?([-.\w]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi;
1253 | 
1254 |   text = text.replace(delimUrlRegex, replaceLink);
1255 |   text = text.replace(delimMailRegex, replaceMail);
1256 |   // simpleURLRegex  = /\b(((https?|ftp|dict):\/\/|www\.)[-.+~:?#@!$&'()*,;=[\]\w]+)\b/gi,
1257 |   // Email addresses: <address@domain.foo>
1258 | 
1259 |   if (options.simplifiedAutoLink) {
1260 |     text = text.replace(simpleURLRegex, replaceLink);
1261 |     text = text.replace(simpleMailRegex, replaceMail);
1262 |   }
1263 | 
1264 |   function replaceLink(wm, link) {
1265 |     var lnkTxt = link;
1266 |     if (/^www\./i.test(link)) {
1267 |       link = link.replace(/^www\./i, 'http://www.');
1268 |     }
1269 |     return '<a href="' + link + '">' + lnkTxt + '</a>';
1270 |   }
1271 | 
1272 |   function replaceMail(wholeMatch, m1) {
1273 |     var unescapedStr = showdown.subParser('unescapeSpecialChars')(m1);
1274 |     return showdown.subParser('encodeEmailAddress')(unescapedStr);
1275 |   }
1276 | 
1277 |   text = globals.converter._dispatch('autoLinks.after', text, options, globals);
1278 | 
1279 |   return text;
1280 | });
1281 | 
1282 | /**
1283 |  * These are all the transformations that form block-level
1284 |  * tags like paragraphs, headers, and list items.
1285 |  */
1286 | showdown.subParser('blockGamut', function (text, options, globals) {
1287 |   'use strict';
1288 | 
1289 |   text = globals.converter._dispatch('blockGamut.before', text, options, globals);
1290 | 
1291 |   // we parse blockquotes first so that we can have headings and hrs
1292 |   // inside blockquotes
1293 |   text = showdown.subParser('blockQuotes')(text, options, globals);
1294 |   text = showdown.subParser('headers')(text, options, globals);
1295 | 
1296 |   // Do Horizontal Rules:
1297 |   var key = showdown.subParser('hashBlock')('<hr />', options, globals);
1298 |   text = text.replace(/^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$/gm, key);
1299 |   text = text.replace(/^[ ]{0,2}([ ]?\-[ ]?){3,}[ \t]*$/gm, key);
1300 |   text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ \t]*$/gm, key);
1301 | 
1302 |   text = showdown.subParser('lists')(text, options, globals);
1303 |   text = showdown.subParser('codeBlocks')(text, options, globals);
1304 |   text = showdown.subParser('tables')(text, options, globals);
1305 | 
1306 |   // We already ran _HashHTMLBlocks() before, in Markdown(), but that
1307 |   // was to escape raw HTML in the original Markdown source. This time,
1308 |   // we're escaping the markup we've just created, so that we don't wrap
1309 |   // <p> tags around block-level tags.
1310 |   text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
1311 |   text = showdown.subParser('paragraphs')(text, options, globals);
1312 | 
1313 |   text = globals.converter._dispatch('blockGamut.after', text, options, globals);
1314 | 
1315 |   return text;
1316 | });
1317 | 
1318 | showdown.subParser('blockQuotes', function (text, options, globals) {
1319 |   'use strict';
1320 | 
1321 |   text = globals.converter._dispatch('blockQuotes.before', text, options, globals);
1322 |   /*
1323 |    text = text.replace(/
1324 |    (								// Wrap whole match in $1
1325 |    (
1326 |    ^[ \t]*>[ \t]?			// '>' at the start of a line
1327 |    .+\n					// rest of the first line
1328 |    (.+\n)*					// subsequent consecutive lines
1329 |    \n*						// blanks
1330 |    )+
1331 |    )
1332 |    /gm, function(){...});
1333 |    */
1334 | 
1335 |   text = text.replace(/((^[ \t]{0,3}>[ \t]?.+\n(.+\n)*\n*)+)/gm, function (wholeMatch, m1) {
1336 |     var bq = m1;
1337 | 
1338 |     // attacklab: hack around Konqueror 3.5.4 bug:
1339 |     // "----------bug".replace(/^-/g,"") == "bug"
1340 |     bq = bq.replace(/^[ \t]*>[ \t]?/gm, '~0'); // trim one level of quoting
1341 | 
1342 |     // attacklab: clean up hack
1343 |     bq = bq.replace(/~0/g, '');
1344 | 
1345 |     bq = bq.replace(/^[ \t]+$/gm, ''); // trim whitespace-only lines
1346 |     bq = showdown.subParser('githubCodeBlocks')(bq, options, globals);
1347 |     bq = showdown.subParser('blockGamut')(bq, options, globals); // recurse
1348 | 
1349 |     bq = bq.replace(/(^|\n)/g, '$1  ');
1350 |     // These leading spaces screw with <pre> content, so we need to fix that:
1351 |     bq = bq.replace(/(\s*<pre>[^\r]+?<\/pre>)/gm, function (wholeMatch, m1) {
1352 |       var pre = m1;
1353 |       // attacklab: hack around Konqueror 3.5.4 bug:
1354 |       pre = pre.replace(/^  /mg, '~0');
1355 |       pre = pre.replace(/~0/g, '');
1356 |       return pre;
1357 |     });
1358 | 
1359 |     return showdown.subParser('hashBlock')('<blockquote>\n' + bq + '\n</blockquote>', options, globals);
1360 |   });
1361 | 
1362 |   text = globals.converter._dispatch('blockQuotes.after', text, options, globals);
1363 |   return text;
1364 | });
1365 | 
1366 | /**
1367 |  * Process Markdown `<pre><code>` blocks.
1368 |  */
1369 | showdown.subParser('codeBlocks', function (text, options, globals) {
1370 |   'use strict';
1371 | 
1372 |   text = globals.converter._dispatch('codeBlocks.before', text, options, globals);
1373 |   /*
1374 |    text = text.replace(text,
1375 |    /(?:\n\n|^)
1376 |    (								// $1 = the code block -- one or more lines, starting with a space/tab
1377 |    (?:
1378 |    (?:[ ]{4}|\t)			// Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width
1379 |    .*\n+
1380 |    )+
1381 |    )
1382 |    (\n*[ ]{0,3}[^ \t\n]|(?=~0))	// attacklab: g_tab_width
1383 |    /g,function(){...});
1384 |    */
1385 | 
1386 |   // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
1387 |   text += '~0';
1388 | 
1389 |   var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=~0))/g;
1390 |   text = text.replace(pattern, function (wholeMatch, m1, m2) {
1391 |     var codeblock = m1,
1392 |         nextChar = m2,
1393 |         end = '\n';
1394 | 
1395 |     codeblock = showdown.subParser('outdent')(codeblock);
1396 |     codeblock = showdown.subParser('encodeCode')(codeblock);
1397 |     codeblock = showdown.subParser('detab')(codeblock);
1398 |     codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
1399 |     codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing newlines
1400 | 
1401 |     if (options.omitExtraWLInCodeBlocks) {
1402 |       end = '';
1403 |     }
1404 | 
1405 |     codeblock = '<pre><code>' + codeblock + end + '</code></pre>';
1406 | 
1407 |     return showdown.subParser('hashBlock')(codeblock, options, globals) + nextChar;
1408 |   });
1409 | 
1410 |   // attacklab: strip sentinel
1411 |   text = text.replace(/~0/, '');
1412 | 
1413 |   text = globals.converter._dispatch('codeBlocks.after', text, options, globals);
1414 |   return text;
1415 | });
1416 | 
1417 | /**
1418 |  *
1419 |  *   *  Backtick quotes are used for <code></code> spans.
1420 |  *
1421 |  *   *  You can use multiple backticks as the delimiters if you want to
1422 |  *     include literal backticks in the code span. So, this input:
1423 |  *
1424 |  *         Just type ``foo `bar` baz`` at the prompt.
1425 |  *
1426 |  *       Will translate to:
1427 |  *
1428 |  *         <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
1429 |  *
1430 |  *    There's no arbitrary limit to the number of backticks you
1431 |  *    can use as delimters. If you need three consecutive backticks
1432 |  *    in your code, use four for delimiters, etc.
1433 |  *
1434 |  *  *  You can use spaces to get literal backticks at the edges:
1435 |  *
1436 |  *         ... type `` `bar` `` ...
1437 |  *
1438 |  *       Turns to:
1439 |  *
1440 |  *         ... type <code>`bar`</code> ...
1441 |  */
1442 | showdown.subParser('codeSpans', function (text, options, globals) {
1443 |   'use strict';
1444 | 
1445 |   text = globals.converter._dispatch('codeSpans.before', text, options, globals);
1446 | 
1447 |   /*
1448 |    text = text.replace(/
1449 |    (^|[^\\])					// Character before opening ` can't be a backslash
1450 |    (`+)						// $2 = Opening run of `
1451 |    (							// $3 = The code block
1452 |    [^\r]*?
1453 |    [^`]					// attacklab: work around lack of lookbehind
1454 |    )
1455 |    \2							// Matching closer
1456 |    (?!`)
1457 |    /gm, function(){...});
1458 |    */
1459 | 
1460 |   if (typeof(text) === 'undefined') {
1461 |     text = '';
1462 |   }
1463 |   text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
1464 |     function (wholeMatch, m1, m2, m3) {
1465 |       var c = m3;
1466 |       c = c.replace(/^([ \t]*)/g, '');	// leading whitespace
1467 |       c = c.replace(/[ \t]*$/g, '');	// trailing whitespace
1468 |       c = showdown.subParser('encodeCode')(c);
1469 |       return m1 + '<code>' + c + '</code>';
1470 |     }
1471 |   );
1472 | 
1473 |   text = globals.converter._dispatch('codeSpans.after', text, options, globals);
1474 |   return text;
1475 | });
1476 | 
1477 | /**
1478 |  * Convert all tabs to spaces
1479 |  */
1480 | showdown.subParser('detab', function (text) {
1481 |   'use strict';
1482 | 
1483 |   // expand first n-1 tabs
1484 |   text = text.replace(/\t(?=\t)/g, '    '); // g_tab_width
1485 | 
1486 |   // replace the nth with two sentinels
1487 |   text = text.replace(/\t/g, '~A~B');
1488 | 
1489 |   // use the sentinel to anchor our regex so it doesn't explode
1490 |   text = text.replace(/~B(.+?)~A/g, function (wholeMatch, m1) {
1491 |     var leadingText = m1,
1492 |         numSpaces = 4 - leadingText.length % 4;  // g_tab_width
1493 | 
1494 |     // there *must* be a better way to do this:
1495 |     for (var i = 0; i < numSpaces; i++) {
1496 |       leadingText += ' ';
1497 |     }
1498 | 
1499 |     return leadingText;
1500 |   });
1501 | 
1502 |   // clean up sentinels
1503 |   text = text.replace(/~A/g, '    ');  // g_tab_width
1504 |   text = text.replace(/~B/g, '');
1505 | 
1506 |   return text;
1507 | 
1508 | });
1509 | 
1510 | /**
1511 |  * Smart processing for ampersands and angle brackets that need to be encoded.
1512 |  */
1513 | showdown.subParser('encodeAmpsAndAngles', function (text) {
1514 |   'use strict';
1515 |   // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
1516 |   // http://bumppo.net/projects/amputator/
1517 |   text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, '&amp;');
1518 | 
1519 |   // Encode naked <'s
1520 |   text = text.replace(/<(?![a-z\/?\$!])/gi, '&lt;');
1521 | 
1522 |   return text;
1523 | });
1524 | 
1525 | /**
1526 |  * Returns the string, with after processing the following backslash escape sequences.
1527 |  *
1528 |  * attacklab: The polite way to do this is with the new escapeCharacters() function:
1529 |  *
1530 |  *    text = escapeCharacters(text,"\\",true);
1531 |  *    text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
1532 |  *
1533 |  * ...but we're sidestepping its use of the (slow) RegExp constructor
1534 |  * as an optimization for Firefox.  This function gets called a LOT.
1535 |  */
1536 | showdown.subParser('encodeBackslashEscapes', function (text) {
1537 |   'use strict';
1538 |   text = text.replace(/\\(\\)/g, showdown.helper.escapeCharactersCallback);
1539 |   text = text.replace(/\\([`*_{}\[\]()>#+-.!])/g, showdown.helper.escapeCharactersCallback);
1540 |   return text;
1541 | });
1542 | 
1543 | /**
1544 |  * Encode/escape certain characters inside Markdown code runs.
1545 |  * The point is that in code, these characters are literals,
1546 |  * and lose their special Markdown meanings.
1547 |  */
1548 | showdown.subParser('encodeCode', function (text) {
1549 |   'use strict';
1550 | 
1551 |   // Encode all ampersands; HTML entities are not
1552 |   // entities within a Markdown code span.
1553 |   text = text.replace(/&/g, '&amp;');
1554 | 
1555 |   // Do the angle bracket song and dance:
1556 |   text = text.replace(/</g, '&lt;');
1557 |   text = text.replace(/>/g, '&gt;');
1558 | 
1559 |   // Now, escape characters that are magic in Markdown:
1560 |   text = showdown.helper.escapeCharacters(text, '*_{}[]\\', false);
1561 | 
1562 |   // jj the line above breaks this:
1563 |   //---
1564 |   //* Item
1565 |   //   1. Subitem
1566 |   //            special char: *
1567 |   // ---
1568 | 
1569 |   return text;
1570 | });
1571 | 
1572 | /**
1573 |  *  Input: an email address, e.g. "foo@example.com"
1574 |  *
1575 |  *  Output: the email address as a mailto link, with each character
1576 |  *    of the address encoded as either a decimal or hex entity, in
1577 |  *    the hopes of foiling most address harvesting spam bots. E.g.:
1578 |  *
1579 |  *    <a href="&#x6D;&#97;&#105;&#108;&#x74;&#111;:&#102;&#111;&#111;&#64;&#101;
1580 |  *       x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;">&#102;&#111;&#111;
1581 |  *       &#64;&#101;x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;</a>
1582 |  *
1583 |  *  Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
1584 |  *  mailing list: <http://tinyurl.com/yu7ue>
1585 |  *
1586 |  */
1587 | showdown.subParser('encodeEmailAddress', function (addr) {
1588 |   'use strict';
1589 | 
1590 |   var encode = [
1591 |     function (ch) {
1592 |       return '&#' + ch.charCodeAt(0) + ';';
1593 |     },
1594 |     function (ch) {
1595 |       return '&#x' + ch.charCodeAt(0).toString(16) + ';';
1596 |     },
1597 |     function (ch) {
1598 |       return ch;
1599 |     }
1600 |   ];
1601 | 
1602 |   addr = 'mailto:' + addr;
1603 | 
1604 |   addr = addr.replace(/./g, function (ch) {
1605 |     if (ch === '@') {
1606 |       // this *must* be encoded. I insist.
1607 |       ch = encode[Math.floor(Math.random() * 2)](ch);
1608 |     } else if (ch !== ':') {
1609 |       // leave ':' alone (to spot mailto: later)
1610 |       var r = Math.random();
1611 |       // roughly 10% raw, 45% hex, 45% dec
1612 |       ch = (
1613 |         r > 0.9 ? encode[2](ch) : r > 0.45 ? encode[1](ch) : encode[0](ch)
1614 |       );
1615 |     }
1616 |     return ch;
1617 |   });
1618 | 
1619 |   addr = '<a href="' + addr + '">' + addr + '</a>';
1620 |   addr = addr.replace(/">.+:/g, '">'); // strip the mailto: from the visible part
1621 | 
1622 |   return addr;
1623 | });
1624 | 
1625 | /**
1626 |  * Within tags -- meaning between < and > -- encode [\ ` * _] so they
1627 |  * don't conflict with their use in Markdown for code, italics and strong.
1628 |  */
1629 | showdown.subParser('escapeSpecialCharsWithinTagAttributes', function (text) {
1630 |   'use strict';
1631 | 
1632 |   // Build a regex to find HTML tags and comments.  See Friedl's
1633 |   // "Mastering Regular Expressions", 2nd Ed., pp. 200-201.
1634 |   var regex = /(<[a-z\/!$]("[^"]*"|'[^']*'|[^'">])*>|<!(--.*?--\s*)+>)/gi;
1635 | 
1636 |   text = text.replace(regex, function (wholeMatch) {
1637 |     var tag = wholeMatch.replace(/(.)<\/?code>(?=.)/g, '$1`');
1638 |     tag = showdown.helper.escapeCharacters(tag, '\\`*_', false);
1639 |     return tag;
1640 |   });
1641 | 
1642 |   return text;
1643 | });
1644 | 
1645 | /**
1646 |  * Handle github codeblocks prior to running HashHTML so that
1647 |  * HTML contained within the codeblock gets escaped properly
1648 |  * Example:
1649 |  * ```ruby
1650 |  *     def hello_world(x)
1651 |  *       puts "Hello, #{x}"
1652 |  *     end
1653 |  * ```
1654 |  */
1655 | showdown.subParser('githubCodeBlocks', function (text, options, globals) {
1656 |   'use strict';
1657 | 
1658 |   // early exit if option is not enabled
1659 |   if (!options.ghCodeBlocks) {
1660 |     return text;
1661 |   }
1662 | 
1663 |   text = globals.converter._dispatch('githubCodeBlocks.before', text, options, globals);
1664 | 
1665 |   text += '~0';
1666 | 
1667 |   text = text.replace(/(?:^|\n)```(.*)\n([\s\S]*?)\n```/g, function (wholeMatch, language, codeblock) {
1668 |     var end = (options.omitExtraWLInCodeBlocks) ? '' : '\n';
1669 | 
1670 |     // First parse the github code block
1671 |     codeblock = showdown.subParser('encodeCode')(codeblock);
1672 |     codeblock = showdown.subParser('detab')(codeblock);
1673 |     codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
1674 |     codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing whitespace
1675 | 
1676 |     codeblock = '<pre><code' + (language ? ' class="' + language + ' language-' + language + '"' : '') + '>' + codeblock + end + '</code></pre>';
1677 | 
1678 |     codeblock = showdown.subParser('hashBlock')(codeblock, options, globals);
1679 | 
1680 |     // Since GHCodeblocks can be false positives, we need to
1681 |     // store the primitive text and the parsed text in a global var,
1682 |     // and then return a token
1683 |     return '\n\n~G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
1684 |   });
1685 | 
1686 |   // attacklab: strip sentinel
1687 |   text = text.replace(/~0/, '');
1688 | 
1689 |   return globals.converter._dispatch('githubCodeBlocks.after', text, options, globals);
1690 | });
1691 | 
1692 | showdown.subParser('hashBlock', function (text, options, globals) {
1693 |   'use strict';
1694 |   text = text.replace(/(^\n+|\n+$)/g, '');
1695 |   return '\n\n~K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\n\n';
1696 | });
1697 | 
1698 | showdown.subParser('hashElement', function (text, options, globals) {
1699 |   'use strict';
1700 | 
1701 |   return function (wholeMatch, m1) {
1702 |     var blockText = m1;
1703 | 
1704 |     // Undo double lines
1705 |     blockText = blockText.replace(/\n\n/g, '\n');
1706 |     blockText = blockText.replace(/^\n/, '');
1707 | 
1708 |     // strip trailing blank lines
1709 |     blockText = blockText.replace(/\n+$/g, '');
1710 | 
1711 |     // Replace the element text with a marker ("~KxK" where x is its key)
1712 |     blockText = '\n\n~K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\n\n';
1713 | 
1714 |     return blockText;
1715 |   };
1716 | });
1717 | 
1718 | showdown.subParser('hashHTMLBlocks', function (text, options, globals) {
1719 |   'use strict';
1720 | 
1721 |   var blockTags = [
1722 |       'pre',
1723 |       'div',
1724 |       'h1',
1725 |       'h2',
1726 |       'h3',
1727 |       'h4',
1728 |       'h5',
1729 |       'h6',
1730 |       'blockquote',
1731 |       'table',
1732 |       'dl',
1733 |       'ol',
1734 |       'ul',
1735 |       'script',
1736 |       'noscript',
1737 |       'form',
1738 |       'fieldset',
1739 |       'iframe',
1740 |       'math',
1741 |       'style',
1742 |       'section',
1743 |       'header',
1744 |       'footer',
1745 |       'nav',
1746 |       'article',
1747 |       'aside',
1748 |       'address',
1749 |       'audio',
1750 |       'canvas',
1751 |       'figure',
1752 |       'hgroup',
1753 |       'output',
1754 |       'video',
1755 |       'p'
1756 |     ],
1757 |     repFunc = function (wholeMatch, match, left, right) {
1758 |       var txt = wholeMatch;
1759 |       // check if this html element is marked as markdown
1760 |       // if so, it's contents should be parsed as markdown
1761 |       if (left.search(/\bmarkdown\b/) !== -1) {
1762 |         txt = left + globals.converter.makeHtml(match) + right;
1763 |       }
1764 |       return '\n\n~K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
1765 |     };
1766 | 
1767 |   for (var i = 0; i < blockTags.length; ++i) {
1768 |     text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^(?: |\\t){0,3}<' + blockTags[i] + '\\b[^>]*>', '</' + blockTags[i] + '>', 'gim');
1769 |   }
1770 | 
1771 |   // HR SPECIAL CASE
1772 |   text = text.replace(/(\n[ ]{0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,
1773 |     showdown.subParser('hashElement')(text, options, globals));
1774 | 
1775 |   // Special case for standalone HTML comments:
1776 |   text = text.replace(/(<!--[\s\S]*?-->)/g,
1777 |     showdown.subParser('hashElement')(text, options, globals));
1778 | 
1779 |   // PHP and ASP-style processor instructions (<?...?> and <%...%>)
1780 |   text = text.replace(/(?:\n\n)([ ]{0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,
1781 |     showdown.subParser('hashElement')(text, options, globals));
1782 |   return text;
1783 | });
1784 | 
1785 | /**
1786 |  * Hash span elements that should not be parsed as markdown
1787 |  */
1788 | showdown.subParser('hashHTMLSpans', function (text, config, globals) {
1789 |   'use strict';
1790 | 
1791 |   var matches = showdown.helper.matchRecursiveRegExp(text, '<code\\b[^>]*>', '</code>', 'gi');
1792 | 
1793 |   for (var i = 0; i < matches.length; ++i) {
1794 |     text = text.replace(matches[i][0], '~L' + (globals.gHtmlSpans.push(matches[i][0]) - 1) + 'L');
1795 |   }
1796 |   return text;
1797 | });
1798 | 
1799 | /**
1800 |  * Unhash HTML spans
1801 |  */
1802 | showdown.subParser('unhashHTMLSpans', function (text, config, globals) {
1803 |   'use strict';
1804 | 
1805 |   for (var i = 0; i < globals.gHtmlSpans.length; ++i) {
1806 |     text = text.replace('~L' + i + 'L', globals.gHtmlSpans[i]);
1807 |   }
1808 | 
1809 |   return text;
1810 | });
1811 | 
1812 | /**
1813 |  * Hash span elements that should not be parsed as markdown
1814 |  */
1815 | showdown.subParser('hashPreCodeTags', function (text, config, globals) {
1816 |   'use strict';
1817 | 
1818 |   var repFunc = function (wholeMatch, match, left, right) {
1819 |     // encode html entities
1820 |     var codeblock = left + showdown.subParser('encodeCode')(match) + right;
1821 |     return '\n\n~G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
1822 |   };
1823 | 
1824 |   text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^(?: |\\t){0,3}<pre\\b[^>]*>\\s*<code\\b[^>]*>', '^(?: |\\t){0,3}</code>\\s*</pre>', 'gim');
1825 |   return text;
1826 | });
1827 | 
1828 | showdown.subParser('headers', function (text, options, globals) {
1829 |   'use strict';
1830 | 
1831 |   text = globals.converter._dispatch('headers.before', text, options, globals);
1832 | 
1833 |   var prefixHeader = options.prefixHeaderId,
1834 |       headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),
1835 | 
1836 |   // Set text-style headers:
1837 |   //	Header 1
1838 |   //	========
1839 |   //
1840 |   //	Header 2
1841 |   //	--------
1842 |   //
1843 |       setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm,
1844 |       setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
1845 | 
1846 |   text = text.replace(setextRegexH1, function (wholeMatch, m1) {
1847 | 
1848 |     var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
1849 |         hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
1850 |         hLevel = headerLevelStart,
1851 |         hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
1852 |     return showdown.subParser('hashBlock')(hashBlock, options, globals);
1853 |   });
1854 | 
1855 |   text = text.replace(setextRegexH2, function (matchFound, m1) {
1856 |     var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
1857 |         hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
1858 |         hLevel = headerLevelStart + 1,
1859 |       hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
1860 |     return showdown.subParser('hashBlock')(hashBlock, options, globals);
1861 |   });
1862 | 
1863 |   // atx-style headers:
1864 |   //  # Header 1
1865 |   //  ## Header 2
1866 |   //  ## Header 2 with closing hashes ##
1867 |   //  ...
1868 |   //  ###### Header 6
1869 |   //
1870 |   text = text.replace(/^(#{1,6})[ \t]*(.+?)[ \t]*#*\n+/gm, function (wholeMatch, m1, m2) {
1871 |     var span = showdown.subParser('spanGamut')(m2, options, globals),
1872 |         hID = (options.noHeaderId) ? '' : ' id="' + headerId(m2) + '"',
1873 |         hLevel = headerLevelStart - 1 + m1.length,
1874 |         header = '<h' + hLevel + hID + '>' + span + '</h' + hLevel + '>';
1875 | 
1876 |     return showdown.subParser('hashBlock')(header, options, globals);
1877 |   });
1878 | 
1879 |   function headerId(m) {
1880 |     var title, escapedId = m.replace(/[^\w]/g, '').toLowerCase();
1881 | 
1882 |     if (globals.hashLinkCounts[escapedId]) {
1883 |       title = escapedId + '-' + (globals.hashLinkCounts[escapedId]++);
1884 |     } else {
1885 |       title = escapedId;
1886 |       globals.hashLinkCounts[escapedId] = 1;
1887 |     }
1888 | 
1889 |     // Prefix id to prevent causing inadvertent pre-existing style matches.
1890 |     if (prefixHeader === true) {
1891 |       prefixHeader = 'section';
1892 |     }
1893 | 
1894 |     if (showdown.helper.isString(prefixHeader)) {
1895 |       return prefixHeader + title;
1896 |     }
1897 |     return title;
1898 |   }
1899 | 
1900 |   text = globals.converter._dispatch('headers.after', text, options, globals);
1901 |   return text;
1902 | });
1903 | 
1904 | /**
1905 |  * Turn Markdown image shortcuts into <img> tags.
1906 |  */
1907 | showdown.subParser('images', function (text, options, globals) {
1908 |   'use strict';
1909 | 
1910 |   text = globals.converter._dispatch('images.before', text, options, globals);
1911 | 
1912 |   var inlineRegExp    = /!\[(.*?)]\s?\([ \t]*()<?(\S+?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(['"])(.*?)\6[ \t]*)?\)/g,
1913 |       referenceRegExp = /!\[([^\]]*?)] ?(?:\n *)?\[(.*?)]()()()()()/g;
1914 | 
1915 |   function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {
1916 | 
1917 |     var gUrls   = globals.gUrls,
1918 |         gTitles = globals.gTitles,
1919 |         gDims   = globals.gDimensions;
1920 | 
1921 |     linkId = linkId.toLowerCase();
1922 | 
1923 |     if (!title) {
1924 |       title = '';
1925 |     }
1926 | 
1927 |     if (url === '' || url === null) {
1928 |       if (linkId === '' || linkId === null) {
1929 |         // lower-case and turn embedded newlines into spaces
1930 |         linkId = altText.toLowerCase().replace(/ ?\n/g, ' ');
1931 |       }
1932 |       url = '#' + linkId;
1933 | 
1934 |       if (!showdown.helper.isUndefined(gUrls[linkId])) {
1935 |         url = gUrls[linkId];
1936 |         if (!showdown.helper.isUndefined(gTitles[linkId])) {
1937 |           title = gTitles[linkId];
1938 |         }
1939 |         if (!showdown.helper.isUndefined(gDims[linkId])) {
1940 |           width = gDims[linkId].width;
1941 |           height = gDims[linkId].height;
1942 |         }
1943 |       } else {
1944 |         return wholeMatch;
1945 |       }
1946 |     }
1947 | 
1948 |     altText = altText.replace(/"/g, '&quot;');
1949 |     altText = showdown.helper.escapeCharacters(altText, '*_', false);
1950 |     url = showdown.helper.escapeCharacters(url, '*_', false);
1951 |     var result = '<img src="' + url + '" alt="' + altText + '"';
1952 | 
1953 |     if (title) {
1954 |       title = title.replace(/"/g, '&quot;');
1955 |       title = showdown.helper.escapeCharacters(title, '*_', false);
1956 |       result += ' title="' + title + '"';
1957 |     }
1958 | 
1959 |     if (width && height) {
1960 |       width  = (width === '*') ? 'auto' : width;
1961 |       height = (height === '*') ? 'auto' : height;
1962 | 
1963 |       result += ' width="' + width + '"';
1964 |       result += ' height="' + height + '"';
1965 |     }
1966 | 
1967 |     result += ' />';
1968 |     return result;
1969 |   }
1970 | 
1971 |   // First, handle reference-style labeled images: ![alt text][id]
1972 |   text = text.replace(referenceRegExp, writeImageTag);
1973 | 
1974 |   // Next, handle inline images:  ![alt text](url =<width>x<height> "optional title")
1975 |   text = text.replace(inlineRegExp, writeImageTag);
1976 | 
1977 |   text = globals.converter._dispatch('images.after', text, options, globals);
1978 |   return text;
1979 | });
1980 | 
1981 | showdown.subParser('italicsAndBold', function (text, options, globals) {
1982 |   'use strict';
1983 | 
1984 |   text = globals.converter._dispatch('italicsAndBold.before', text, options, globals);
1985 | 
1986 |   if (options.literalMidWordUnderscores) {
1987 |     //underscores
1988 |     // Since we are consuming a \s character, we need to add it
1989 |     text = text.replace(/(^|\s|>|\b)__(?=\S)([\s\S]+?)__(?=\b|<|\s|$)/gm, '$1<strong>$2</strong>');
1990 |     text = text.replace(/(^|\s|>|\b)_(?=\S)([\s\S]+?)_(?=\b|<|\s|$)/gm, '$1<em>$2</em>');
1991 |     //asterisks
1992 |     text = text.replace(/(\*\*)(?=\S)([^\r]*?\S[*]*)\1/g, '<strong>$2</strong>');
1993 |     text = text.replace(/(\*)(?=\S)([^\r]*?\S)\1/g, '<em>$2</em>');
1994 | 
1995 |   } else {
1996 |     // <strong> must go first:
1997 |     text = text.replace(/(\*\*|__)(?=\S)([^\r]*?\S[*_]*)\1/g, '<strong>$2</strong>');
1998 |     text = text.replace(/(\*|_)(?=\S)([^\r]*?\S)\1/g, '<em>$2</em>');
1999 |   }
2000 | 
2001 |   text = globals.converter._dispatch('italicsAndBold.after', text, options, globals);
2002 |   return text;
2003 | });
2004 | 
2005 | /**
2006 |  * Form HTML ordered (numbered) and unordered (bulleted) lists.
2007 |  */
2008 | showdown.subParser('lists', function (text, options, globals) {
2009 |   'use strict';
2010 | 
2011 |   text = globals.converter._dispatch('lists.before', text, options, globals);
2012 |   /**
2013 |    * Process the contents of a single ordered or unordered list, splitting it
2014 |    * into individual list items.
2015 |    * @param {string} listStr
2016 |    * @param {boolean} trimTrailing
2017 |    * @returns {string}
2018 |    */
2019 |   function processListItems (listStr, trimTrailing) {
2020 |     // The $g_list_level global keeps track of when we're inside a list.
2021 |     // Each time we enter a list, we increment it; when we leave a list,
2022 |     // we decrement. If it's zero, we're not in a list anymore.
2023 |     //
2024 |     // We do this because when we're not inside a list, we want to treat
2025 |     // something like this:
2026 |     //
2027 |     //    I recommend upgrading to version
2028 |     //    8. Oops, now this line is treated
2029 |     //    as a sub-list.
2030 |     //
2031 |     // As a single paragraph, despite the fact that the second line starts
2032 |     // with a digit-period-space sequence.
2033 |     //
2034 |     // Whereas when we're inside a list (or sub-list), that line will be
2035 |     // treated as the start of a sub-list. What a kludge, huh? This is
2036 |     // an aspect of Markdown's syntax that's hard to parse perfectly
2037 |     // without resorting to mind-reading. Perhaps the solution is to
2038 |     // change the syntax rules such that sub-lists must start with a
2039 |     // starting cardinal number; e.g. "1." or "a.".
2040 |     globals.gListLevel++;
2041 | 
2042 |     // trim trailing blank lines:
2043 |     listStr = listStr.replace(/\n{2,}$/, '\n');
2044 | 
2045 |     // attacklab: add sentinel to emulate \z
2046 |     listStr += '~0';
2047 | 
2048 |     var rgx = /(\n)?(^[ \t]*)([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(~0|\2([*+-]|\d+[.])[ \t]+))/gm,
2049 |         isParagraphed = (/\n[ \t]*\n(?!~0)/.test(listStr));
2050 | 
2051 |     listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {
2052 |       checked = (checked && checked.trim() !== '');
2053 |       var item = showdown.subParser('outdent')(m4, options, globals),
2054 |           bulletStyle = '';
2055 | 
2056 |       // Support for github tasklists
2057 |       if (taskbtn && options.tasklists) {
2058 |         bulletStyle = ' class="task-list-item" style="list-style-type: none;"';
2059 |         item = item.replace(/^[ \t]*\[(x|X| )?]/m, function () {
2060 |           var otp = '<input type="checkbox" disabled style="margin: 0px 0.35em 0.25em -1.6em; vertical-align: middle;"';
2061 |           if (checked) {
2062 |             otp += ' checked';
2063 |           }
2064 |           otp += '>';
2065 |           return otp;
2066 |         });
2067 |       }
2068 |       // m1 - Leading line or
2069 |       // Has a double return (multi paragraph) or
2070 |       // Has sublist
2071 |       if (m1 || (item.search(/\n{2,}/) > -1)) {
2072 |         item = showdown.subParser('githubCodeBlocks')(item, options, globals);
2073 |         item = showdown.subParser('blockGamut')(item, options, globals);
2074 |       } else {
2075 |         // Recursion for sub-lists:
2076 |         item = showdown.subParser('lists')(item, options, globals);
2077 |         item = item.replace(/\n$/, ''); // chomp(item)
2078 |         if (isParagraphed) {
2079 |           item = showdown.subParser('paragraphs')(item, options, globals);
2080 |         } else {
2081 |           item = showdown.subParser('spanGamut')(item, options, globals);
2082 |         }
2083 |       }
2084 |       item =  '\n<li' + bulletStyle + '>' + item + '</li>\n';
2085 |       return item;
2086 |     });
2087 | 
2088 |     // attacklab: strip sentinel
2089 |     listStr = listStr.replace(/~0/g, '');
2090 | 
2091 |     globals.gListLevel--;
2092 | 
2093 |     if (trimTrailing) {
2094 |       listStr = listStr.replace(/\s+$/, '');
2095 |     }
2096 | 
2097 |     return listStr;
2098 |   }
2099 | 
2100 |   /**
2101 |    * Check and parse consecutive lists (better fix for issue #142)
2102 |    * @param {string} list
2103 |    * @param {string} listType
2104 |    * @param {boolean} trimTrailing
2105 |    * @returns {string}
2106 |    */
2107 |   function parseConsecutiveLists(list, listType, trimTrailing) {
2108 |     // check if we caught 2 or more consecutive lists by mistake
2109 |     // we use the counterRgx, meaning if listType is UL we look for UL and vice versa
2110 |     var counterRxg = (listType === 'ul') ? /^ {0,2}\d+\.[ \t]/gm : /^ {0,2}[*+-][ \t]/gm,
2111 |       subLists = [],
2112 |       result = '';
2113 | 
2114 |     if (list.search(counterRxg) !== -1) {
2115 |       (function parseCL(txt) {
2116 |         var pos = txt.search(counterRxg);
2117 |         if (pos !== -1) {
2118 |           // slice
2119 |           result += '\n\n<' + listType + '>' + processListItems(txt.slice(0, pos), !!trimTrailing) + '</' + listType + '>\n\n';
2120 | 
2121 |           // invert counterType and listType
2122 |           listType = (listType === 'ul') ? 'ol' : 'ul';
2123 |           counterRxg = (listType === 'ul') ? /^ {0,2}\d+\.[ \t]/gm : /^ {0,2}[*+-][ \t]/gm;
2124 | 
2125 |           //recurse
2126 |           parseCL(txt.slice(pos));
2127 |         } else {
2128 |           result += '\n\n<' + listType + '>' + processListItems(txt, !!trimTrailing) + '</' + listType + '>\n\n';
2129 |         }
2130 |       })(list);
2131 |       for (var i = 0; i < subLists.length; ++i) {
2132 | 
2133 |       }
2134 |     } else {
2135 |       result = '\n\n<' + listType + '>' + processListItems(list, !!trimTrailing) + '</' + listType + '>\n\n';
2136 |     }
2137 | 
2138 |     return result;
2139 |   }
2140 | 
2141 |   // attacklab: add sentinel to hack around khtml/safari bug:
2142 |   // http://bugs.webkit.org/show_bug.cgi?id=11231
2143 |   text += '~0';
2144 | 
2145 |   // Re-usable pattern to match any entire ul or ol list:
2146 |   var wholeList = /^(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
2147 | 
2148 |   if (globals.gListLevel) {
2149 |     text = text.replace(wholeList, function (wholeMatch, list, m2) {
2150 |       var listType = (m2.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
2151 |       return parseConsecutiveLists(list, listType, true);
2152 |     });
2153 |   } else {
2154 |     wholeList = /(\n\n|^\n?)(([ ]{0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(~0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm;
2155 |     //wholeList = /(\n\n|^\n?)( {0,3}([*+-]|\d+\.)[ \t]+[\s\S]+?)(?=(~0)|(\n\n(?!\t| {2,}| {0,3}([*+-]|\d+\.)[ \t])))/g;
2156 |     text = text.replace(wholeList, function (wholeMatch, m1, list, m3) {
2157 | 
2158 |       var listType = (m3.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
2159 |       return parseConsecutiveLists(list, listType);
2160 |     });
2161 |   }
2162 | 
2163 |   // attacklab: strip sentinel
2164 |   text = text.replace(/~0/, '');
2165 | 
2166 |   text = globals.converter._dispatch('lists.after', text, options, globals);
2167 |   return text;
2168 | });
2169 | 
2170 | /**
2171 |  * Remove one level of line-leading tabs or spaces
2172 |  */
2173 | showdown.subParser('outdent', function (text) {
2174 |   'use strict';
2175 | 
2176 |   // attacklab: hack around Konqueror 3.5.4 bug:
2177 |   // "----------bug".replace(/^-/g,"") == "bug"
2178 |   text = text.replace(/^(\t|[ ]{1,4})/gm, '~0'); // attacklab: g_tab_width
2179 | 
2180 |   // attacklab: clean up hack
2181 |   text = text.replace(/~0/g, '');
2182 | 
2183 |   return text;
2184 | });
2185 | 
2186 | /**
2187 |  *
2188 |  */
2189 | showdown.subParser('paragraphs', function (text, options, globals) {
2190 |   'use strict';
2191 | 
2192 |   text = globals.converter._dispatch('paragraphs.before', text, options, globals);
2193 |   // Strip leading and trailing lines:
2194 |   text = text.replace(/^\n+/g, '');
2195 |   text = text.replace(/\n+$/g, '');
2196 | 
2197 |   var grafs = text.split(/\n{2,}/g),
2198 |       grafsOut = [],
2199 |       end = grafs.length; // Wrap <p> tags
2200 | 
2201 |   for (var i = 0; i < end; i++) {
2202 |     var str = grafs[i];
2203 |     // if this is an HTML marker, copy it
2204 |     if (str.search(/~(K|G)(\d+)\1/g) >= 0) {
2205 |       grafsOut.push(str);
2206 |     } else {
2207 |       str = showdown.subParser('spanGamut')(str, options, globals);
2208 |       str = str.replace(/^([ \t]*)/g, '<p>');
2209 |       str += '</p>';
2210 |       grafsOut.push(str);
2211 |     }
2212 |   }
2213 | 
2214 |   /** Unhashify HTML blocks */
2215 |   end = grafsOut.length;
2216 |   for (i = 0; i < end; i++) {
2217 |     var blockText = '',
2218 |         grafsOutIt = grafsOut[i],
2219 |         codeFlag = false;
2220 |     // if this is a marker for an html block...
2221 |     while (grafsOutIt.search(/~(K|G)(\d+)\1/) >= 0) {
2222 |       var delim = RegExp.$1,
2223 |           num   = RegExp.$2;
2224 | 
2225 |       if (delim === 'K') {
2226 |         blockText = globals.gHtmlBlocks[num];
2227 |       } else {
2228 |         // we need to check if ghBlock is a false positive
2229 |         if (codeFlag) {
2230 |           // use encoded version of all text
2231 |           blockText = showdown.subParser('encodeCode')(globals.ghCodeBlocks[num].text);
2232 |         } else {
2233 |           blockText = globals.ghCodeBlocks[num].codeblock;
2234 |         }
2235 |       }
2236 |       blockText = blockText.replace(/\$/g, '$$$$'); // Escape any dollar signs
2237 | 
2238 |       grafsOutIt = grafsOutIt.replace(/(\n\n)?~(K|G)\d+\2(\n\n)?/, blockText);
2239 |       // Check if grafsOutIt is a pre->code
2240 |       if (/^<pre\b[^>]*>\s*<code\b[^>]*>/.test(grafsOutIt)) {
2241 |         codeFlag = true;
2242 |       }
2243 |     }
2244 |     grafsOut[i] = grafsOutIt;
2245 |   }
2246 |   text = grafsOut.join('\n\n');
2247 |   // Strip leading and trailing lines:
2248 |   text = text.replace(/^\n+/g, '');
2249 |   text = text.replace(/\n+$/g, '');
2250 |   return globals.converter._dispatch('paragraphs.after', text, options, globals);
2251 | });
2252 | 
2253 | /**
2254 |  * Run extension
2255 |  */
2256 | showdown.subParser('runExtension', function (ext, text, options, globals) {
2257 |   'use strict';
2258 | 
2259 |   if (ext.filter) {
2260 |     text = ext.filter(text, globals.converter, options);
2261 | 
2262 |   } else if (ext.regex) {
2263 |     // TODO remove this when old extension loading mechanism is deprecated
2264 |     var re = ext.regex;
2265 |     if (!re instanceof RegExp) {
2266 |       re = new RegExp(re, 'g');
2267 |     }
2268 |     text = text.replace(re, ext.replace);
2269 |   }
2270 | 
2271 |   return text;
2272 | });
2273 | 
2274 | /**
2275 |  * These are all the transformations that occur *within* block-level
2276 |  * tags like paragraphs, headers, and list items.
2277 |  */
2278 | showdown.subParser('spanGamut', function (text, options, globals) {
2279 |   'use strict';
2280 | 
2281 |   text = globals.converter._dispatch('spanGamut.before', text, options, globals);
2282 |   text = showdown.subParser('codeSpans')(text, options, globals);
2283 |   text = showdown.subParser('escapeSpecialCharsWithinTagAttributes')(text, options, globals);
2284 |   text = showdown.subParser('encodeBackslashEscapes')(text, options, globals);
2285 | 
2286 |   // Process anchor and image tags. Images must come first,
2287 |   // because ![foo][f] looks like an anchor.
2288 |   text = showdown.subParser('images')(text, options, globals);
2289 |   text = showdown.subParser('anchors')(text, options, globals);
2290 | 
2291 |   // Make links out of things like `<http://example.com/>`
2292 |   // Must come after _DoAnchors(), because you can use < and >
2293 |   // delimiters in inline links like [this](<url>).
2294 |   text = showdown.subParser('autoLinks')(text, options, globals);
2295 |   text = showdown.subParser('encodeAmpsAndAngles')(text, options, globals);
2296 |   text = showdown.subParser('italicsAndBold')(text, options, globals);
2297 |   text = showdown.subParser('strikethrough')(text, options, globals);
2298 | 
2299 |   // Do hard breaks:
2300 |   text = text.replace(/  +\n/g, ' <br />\n');
2301 | 
2302 |   text = globals.converter._dispatch('spanGamut.after', text, options, globals);
2303 |   return text;
2304 | });
2305 | 
2306 | showdown.subParser('strikethrough', function (text, options, globals) {
2307 |   'use strict';
2308 | 
2309 |   if (options.strikethrough) {
2310 |     text = globals.converter._dispatch('strikethrough.before', text, options, globals);
2311 |     text = text.replace(/(?:~T){2}([\s\S]+?)(?:~T){2}/g, '<del>$1</del>');
2312 |     text = globals.converter._dispatch('strikethrough.after', text, options, globals);
2313 |   }
2314 | 
2315 |   return text;
2316 | });
2317 | 
2318 | /**
2319 |  * Strip any lines consisting only of spaces and tabs.
2320 |  * This makes subsequent regexs easier to write, because we can
2321 |  * match consecutive blank lines with /\n+/ instead of something
2322 |  * contorted like /[ \t]*\n+/
2323 |  */
2324 | showdown.subParser('stripBlankLines', function (text) {
2325 |   'use strict';
2326 |   return text.replace(/^[ \t]+$/mg, '');
2327 | });
2328 | 
2329 | /**
2330 |  * Strips link definitions from text, stores the URLs and titles in
2331 |  * hash references.
2332 |  * Link defs are in the form: ^[id]: url "optional title"
2333 |  *
2334 |  * ^[ ]{0,3}\[(.+)\]: // id = $1  attacklab: g_tab_width - 1
2335 |  * [ \t]*
2336 |  * \n?                  // maybe *one* newline
2337 |  * [ \t]*
2338 |  * <?(\S+?)>?          // url = $2
2339 |  * [ \t]*
2340 |  * \n?                // maybe one newline
2341 |  * [ \t]*
2342 |  * (?:
2343 |  * (\n*)              // any lines skipped = $3 attacklab: lookbehind removed
2344 |  * ["(]
2345 |  * (.+?)              // title = $4
2346 |  * [")]
2347 |  * [ \t]*
2348 |  * )?                 // title is optional
2349 |  * (?:\n+|$)
2350 |  * /gm,
2351 |  * function(){...});
2352 |  *
2353 |  */
2354 | showdown.subParser('stripLinkDefinitions', function (text, options, globals) {
2355 |   'use strict';
2356 | 
2357 |   var regex = /^ {0,3}\[(.+)]:[ \t]*\n?[ \t]*<?(\S+?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*\n?[ \t]*(?:(\n*)["|'(](.+?)["|')][ \t]*)?(?:\n+|(?=~0))/gm;
2358 | 
2359 |   // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
2360 |   text += '~0';
2361 | 
2362 |   text = text.replace(regex, function (wholeMatch, linkId, url, width, height, blankLines, title) {
2363 |     linkId = linkId.toLowerCase();
2364 |     globals.gUrls[linkId] = showdown.subParser('encodeAmpsAndAngles')(url);  // Link IDs are case-insensitive
2365 | 
2366 |     if (blankLines) {
2367 |       // Oops, found blank lines, so it's not a title.
2368 |       // Put back the parenthetical statement we stole.
2369 |       return blankLines + title;
2370 | 
2371 |     } else {
2372 |       if (title) {
2373 |         globals.gTitles[linkId] = title.replace(/"|'/g, '&quot;');
2374 |       }
2375 |       if (options.parseImgDimensions && width && height) {
2376 |         globals.gDimensions[linkId] = {
2377 |           width:  width,
2378 |           height: height
2379 |         };
2380 |       }
2381 |     }
2382 |     // Completely remove the definition from the text
2383 |     return '';
2384 |   });
2385 | 
2386 |   // attacklab: strip sentinel
2387 |   text = text.replace(/~0/, '');
2388 | 
2389 |   return text;
2390 | });
2391 | 
2392 | showdown.subParser('tables', function (text, options, globals) {
2393 |   'use strict';
2394 | 
2395 |   if (!options.tables) {
2396 |     return text;
2397 |   }
2398 | 
2399 |   var tableRgx = /^[ \t]{0,3}\|?.+\|.+\n[ \t]{0,3}\|?[ \t]*:?[ \t]*(?:-|=){2,}[ \t]*:?[ \t]*\|[ \t]*:?[ \t]*(?:-|=){2,}[\s\S]+?(?:\n\n|~0)/gm;
2400 | 
2401 |   function parseStyles(sLine) {
2402 |     if (/^:[ \t]*--*$/.test(sLine)) {
2403 |       return ' style="text-align:left;"';
2404 |     } else if (/^--*[ \t]*:[ \t]*$/.test(sLine)) {
2405 |       return ' style="text-align:right;"';
2406 |     } else if (/^:[ \t]*--*[ \t]*:$/.test(sLine)) {
2407 |       return ' style="text-align:center;"';
2408 |     } else {
2409 |       return '';
2410 |     }
2411 |   }
2412 | 
2413 |   function parseHeaders(header, style) {
2414 |     var id = '';
2415 |     header = header.trim();
2416 |     if (options.tableHeaderId) {
2417 |       id = ' id="' + header.replace(/ /g, '_').toLowerCase() + '"';
2418 |     }
2419 |     header = showdown.subParser('spanGamut')(header, options, globals);
2420 | 
2421 |     return '<th' + id + style + '>' + header + '</th>\n';
2422 |   }
2423 | 
2424 |   function parseCells(cell, style) {
2425 |     var subText = showdown.subParser('spanGamut')(cell, options, globals);
2426 |     return '<td' + style + '>' + subText + '</td>\n';
2427 |   }
2428 | 
2429 |   function buildTable(headers, cells) {
2430 |     var tb = '<table>\n<thead>\n<tr>\n',
2431 |         tblLgn = headers.length;
2432 | 
2433 |     for (var i = 0; i < tblLgn; ++i) {
2434 |       tb += headers[i];
2435 |     }
2436 |     tb += '</tr>\n</thead>\n<tbody>\n';
2437 | 
2438 |     for (i = 0; i < cells.length; ++i) {
2439 |       tb += '<tr>\n';
2440 |       for (var ii = 0; ii < tblLgn; ++ii) {
2441 |         tb += cells[i][ii];
2442 |       }
2443 |       tb += '</tr>\n';
2444 |     }
2445 |     tb += '</tbody>\n</table>\n';
2446 |     return tb;
2447 |   }
2448 | 
2449 |   text = globals.converter._dispatch('tables.before', text, options, globals);
2450 | 
2451 |   text = text.replace(tableRgx, function (rawTable) {
2452 | 
2453 |     var i, tableLines = rawTable.split('\n');
2454 | 
2455 |     // strip wrong first and last column if wrapped tables are used
2456 |     for (i = 0; i < tableLines.length; ++i) {
2457 |       if (/^[ \t]{0,3}\|/.test(tableLines[i])) {
2458 |         tableLines[i] = tableLines[i].replace(/^[ \t]{0,3}\|/, '');
2459 |       }
2460 |       if (/\|[ \t]*$/.test(tableLines[i])) {
2461 |         tableLines[i] = tableLines[i].replace(/\|[ \t]*$/, '');
2462 |       }
2463 |     }
2464 | 
2465 |     var rawHeaders = tableLines[0].split('|').map(function (s) { return s.trim();}),
2466 |         rawStyles = tableLines[1].split('|').map(function (s) { return s.trim();}),
2467 |         rawCells = [],
2468 |         headers = [],
2469 |         styles = [],
2470 |         cells = [];
2471 | 
2472 |     tableLines.shift();
2473 |     tableLines.shift();
2474 | 
2475 |     for (i = 0; i < tableLines.length; ++i) {
2476 |       if (tableLines[i].trim() === '') {
2477 |         continue;
2478 |       }
2479 |       rawCells.push(
2480 |         tableLines[i]
2481 |           .split('|')
2482 |           .map(function (s) {
2483 |             return s.trim();
2484 |           })
2485 |       );
2486 |     }
2487 | 
2488 |     if (rawHeaders.length < rawStyles.length) {
2489 |       return rawTable;
2490 |     }
2491 | 
2492 |     for (i = 0; i < rawStyles.length; ++i) {
2493 |       styles.push(parseStyles(rawStyles[i]));
2494 |     }
2495 | 
2496 |     for (i = 0; i < rawHeaders.length; ++i) {
2497 |       if (showdown.helper.isUndefined(styles[i])) {
2498 |         styles[i] = '';
2499 |       }
2500 |       headers.push(parseHeaders(rawHeaders[i], styles[i]));
2501 |     }
2502 | 
2503 |     for (i = 0; i < rawCells.length; ++i) {
2504 |       var row = [];
2505 |       for (var ii = 0; ii < headers.length; ++ii) {
2506 |         if (showdown.helper.isUndefined(rawCells[i][ii])) {
2507 | 
2508 |         }
2509 |         row.push(parseCells(rawCells[i][ii], styles[ii]));
2510 |       }
2511 |       cells.push(row);
2512 |     }
2513 | 
2514 |     return buildTable(headers, cells);
2515 |   });
2516 | 
2517 |   text = globals.converter._dispatch('tables.after', text, options, globals);
2518 | 
2519 |   return text;
2520 | });
2521 | 
2522 | /**
2523 |  * Swap back in all the special characters we've hidden.
2524 |  */
2525 | showdown.subParser('unescapeSpecialChars', function (text) {
2526 |   'use strict';
2527 | 
2528 |   text = text.replace(/~E(\d+)E/g, function (wholeMatch, m1) {
2529 |     var charCodeToReplace = parseInt(m1);
2530 |     return String.fromCharCode(charCodeToReplace);
2531 |   });
2532 |   return text;
2533 | });
2534 | 
2535 | var root = this;
2536 | 
2537 | // CommonJS/nodeJS Loader
2538 | if (typeof module !== 'undefined' && module.exports) {
2539 |   module.exports = showdown;
2540 | 
2541 | // AMD Loader
2542 | } else if (typeof define === 'function' && define.amd) {
2543 |   define(function () {
2544 |     'use strict';
2545 |     return showdown;
2546 |   });
2547 | 
2548 | // Regular Browser loader
2549 | } else {
2550 |   root.showdown = showdown;
2551 | }
2552 | }).call(this);
2553 | 
2554 | //# sourceMappingURL=showdown.js.map
2555 | 


--------------------------------------------------------------------------------