├── pages
    ├── home
    │   ├── home.json
    │   ├── home.wxml
    │   ├── home.wxss
    │   ├── home-model.js
    │   └── home.js
    ├── detail
    │   ├── detail.json
    │   ├── detail-model.js
    │   ├── detail.js
    │   ├── detail.wxss
    │   └── detail.wxml
    ├── qr-pay
    │   ├── qr-json.json
    │   ├── qr-pay-model.js
    │   ├── qr-pay.wxml
    │   ├── qr-pay.js
    │   └── qr-pay.wxss
    ├── after-pay
    │   ├── after-pay.json
    │   ├── after-pay.js
    │   ├── after-pay.wxss
    │   └── after-pay.wxml
    ├── before-pay
    │   ├── before-pay.json
    │   ├── before-pay-model.js
    │   ├── before-pay.wxml
    │   ├── before-pay.wxss
    │   └── before-pay.js
    └── pay-success
    │   ├── pay-success.json
    │   ├── pay-success.wxss
    │   ├── pay-success.js
    │   └── pay-success.wxml
├── jsconfig.json
├── utils
    ├── config.js
    ├── base.js
    └── token.js
├── app.js
├── app.json
├── common
    ├── coupon
    │   ├── index.wxml
    │   └── index.wxss
    └── wxParse
    │   ├── wxParse.wxss
    │   ├── wxParse.js
    │   ├── htmlparser.js
    │   ├── wxDiscode.js
    │   ├── html2json.js
    │   ├── wxParse.wxml
    │   └── showdown.js
├── app.wxss
├── README.md
└── LICENSE


/pages/home/home.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "我的优惠券"
3 | }


--------------------------------------------------------------------------------
/pages/detail/detail.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "优惠券详情"
3 | }


--------------------------------------------------------------------------------
/pages/qr-pay/qr-json.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "支付"
3 | }


--------------------------------------------------------------------------------
/pages/after-pay/after-pay.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "购买成功"
3 | }


--------------------------------------------------------------------------------
/pages/before-pay/before-pay.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "确认订单"
3 | }


--------------------------------------------------------------------------------
/pages/pay-success/pay-success.json:
--------------------------------------------------------------------------------
1 | {
2 |   "navigationBarTitleText": "支付成功"
3 | }


--------------------------------------------------------------------------------
/jsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"compilerOptions": {
3 | 		"target": "es2015",
4 | 		"module": "commonjs"
5 | 	}	
6 | }


--------------------------------------------------------------------------------
/utils/config.js:
--------------------------------------------------------------------------------
1 | const Config = {
2 |   baseUrl: 'https://gjb.demo.chilunyc.com/api/weapp/',
3 | }
4 | 
5 | export default Config


--------------------------------------------------------------------------------
/pages/home/home.wxml:
--------------------------------------------------------------------------------
1 | <view class="coupon_list">
2 |   <import src="../../common/coupon/index.wxml" />
3 |   <template is="coupon" wx:key="{{item.coupon_id}}" data="{{item}}" wx:for="{{coupons}}" />
4 | </view>


--------------------------------------------------------------------------------
/pages/home/home.wxss:
--------------------------------------------------------------------------------
 1 | /**index.wxss**/
 2 | @import '../../common/coupon/index.wxss';
 3 | 
 4 | .coupon_list {
 5 |   width: 100%;
 6 |   height: auto;
 7 |   margin-top: 20rpx;
 8 |   padding: 0 24rpx;
 9 |   box-sizing: border-box;
10 | }


--------------------------------------------------------------------------------
/app.js:
--------------------------------------------------------------------------------
 1 | import Token from 'utils/token'
 2 | 
 3 | App({
 4 |   onLaunch() {
 5 |     /*  
 6 |      * token 过期速度远远快于微信的 session（用户登录态），
 7 |      * 获取 token 会更新微信的 session，故这里不需要执行 wx.checkSession 
 8 |      */
 9 |     
10 |     const token = new Token()
11 |     token.verify()
12 |   }
13 | })


--------------------------------------------------------------------------------
/pages/home/home-model.js:
--------------------------------------------------------------------------------
 1 | import Base from '../../utils/base'
 2 | 
 3 | export default class HomeModel extends Base {
 4 |   constructor() {
 5 |     super()
 6 |   }
 7 | 
 8 |   getCouponsData(successCb) {
 9 |     const params = {
10 |       url: 'coupons',
11 |       successCb,
12 |     }
13 |     this.request(params)
14 |   }
15 | }


--------------------------------------------------------------------------------
/pages/home/home.js:
--------------------------------------------------------------------------------
 1 | import HomeModel from './home-model'
 2 | const homeModel = new HomeModel()
 3 | 
 4 | Page({
 5 |   data: {
 6 |     coupons: [],
 7 |   },
 8 |   onLoad() {
 9 |     this._fetchData()
10 |   },
11 | 
12 |   _fetchData() {
13 |     homeModel.getCouponsData(res => {
14 |       this.setData({
15 |         coupons: res.data
16 |       })
17 |     })
18 |   },
19 | })
20 | 


--------------------------------------------------------------------------------
/pages/detail/detail-model.js:
--------------------------------------------------------------------------------
 1 | import Base from '../../utils/base'
 2 | 
 3 | export default class DetailModel extends Base {
 4 |   constructor() {
 5 |     super()
 6 |   }
 7 | 
 8 |   getCouponDetailData(data, successCb) {
 9 |     const params = {
10 |       url: 'coupons/' + data.id,
11 |       data: {
12 |         order_id: data.order_id,
13 |       },
14 |       successCb,
15 |     }
16 |     this.request(params)
17 |   }
18 | }


--------------------------------------------------------------------------------
/app.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "pages":[
 3 |     "pages/home/home",
 4 |     "pages/detail/detail",
 5 |     "pages/after-pay/after-pay", 
 6 |     "pages/before-pay/before-pay",
 7 |     "pages/qr-pay/qr-pay",    
 8 |     "pages/pay-success/pay-success"
 9 |   ],
10 |   "window":{
11 |     "backgroundTextStyle":"light",
12 |     "navigationBarBackgroundColor": "#fff",
13 |     "navigationBarTitleText": "我的优惠券",
14 |     "navigationBarTextStyle":"black"
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/pages/qr-pay/qr-pay-model.js:
--------------------------------------------------------------------------------
 1 | import Base from '../../utils/base'
 2 | 
 3 | export default class QrPayModel extends Base {
 4 |   constructor() {
 5 |     super()
 6 |   }
 7 | 
 8 |   getMerchantsInfo(merchant_id, successCb) {
 9 |     const params = {
10 |       url: 'merchants/' + merchant_id,
11 |       successCb,
12 |     }
13 |     this.request(params)
14 |   }
15 | 
16 |   wxPay(data, successCb) {
17 |     const params = {
18 |       url: 'consumes/',
19 |       type: 'POST',
20 |       data,
21 |       successCb,
22 |     }
23 |     this.request(params)
24 |   }
25 | }


--------------------------------------------------------------------------------
/common/coupon/index.wxml:
--------------------------------------------------------------------------------
 1 | <template name="coupon">
 2 |   <navigator 
 3 |     class="coupon {{item.status ? 'used' : 'bg-white'}}" 
 4 |     url="../detail/detail?id={{item.id}}&order_id={{item.order_id}}" 
 5 |     open-type="navigateTo"
 6 |   >
 7 |     <image class="img" src="{{item.logo}}" mode="aspectFill"></image>
 8 |     <view class="hd">
 9 |       <text class="name">{{item.merchant_name}}</text>
10 |       <text class="price">{{item.coupon_name}}</text>
11 |       <text class="desc">{{item.price}} 元代 {{item.face_value}} 元</text>
12 |     </view>
13 |   </navigator>
14 | </template>
15 | 


--------------------------------------------------------------------------------
/pages/pay-success/pay-success.wxss:
--------------------------------------------------------------------------------
 1 | .weui-msg {
 2 |   padding-top: 36px;
 3 |   text-align: center;
 4 | }
 5 | 
 6 | .weui-msg__icon-area {
 7 |   margin-bottom: 30px;
 8 | }
 9 | 
10 | .weui-msg__text-area {
11 |   margin-bottom: 40px;
12 |   padding:0 20px;
13 | }
14 | 
15 | .weui-msg__title {
16 |   margin-bottom: 30px;
17 |   font-weight: 400;
18 |   font-size: 20px;
19 | }
20 | 
21 | .weui-msg__desc {
22 |   font-size: 14px;
23 |   color: #83889A;
24 | }
25 | 
26 | .weui-msg__desc text {
27 |   display: block;
28 |   line-height: 24px;  
29 | }
30 | 
31 | .weui-btn-area {
32 |   width: 100%;
33 |   padding: 0 24rpx;
34 |   box-sizing: border-box;
35 | }


--------------------------------------------------------------------------------
/pages/pay-success/pay-success.js:
--------------------------------------------------------------------------------
 1 | Page({
 2 |   data:{
 3 |     nonce_str: '',
 4 |     consume: '',
 5 |     couponTotal: '',
 6 |     pay_sum: '',
 7 |   },
 8 |   onLoad(options){
 9 |     console.log('pay-success-options', options)
10 |     const {
11 |       nonce_str = '',
12 |       consume = 0,
13 |       couponTotal = 0,
14 |       pay_sum = 0,
15 |     } = options
16 | 
17 |     this.setData({
18 |       nonce_str,
19 |       consume,
20 |       couponTotal,
21 |       pay_sum,
22 |     })
23 |   },
24 | 
25 |   linkIndexPage() {
26 |     // TODO 如果这个用户，没用优惠券，直接付款呢？
27 |     wx.redirectTo({
28 |       url: '/pages/home/home'
29 |     })
30 |   },
31 | })


--------------------------------------------------------------------------------
/pages/after-pay/after-pay.js:
--------------------------------------------------------------------------------
 1 | Page({
 2 |   data:{
 3 |     name: '',
 4 |     id: '',
 5 |     num: '',
 6 |     order_time: '',
 7 |     nonce_str: '',
 8 |   },
 9 |   onLoad(options){
10 |     console.log('after-pay-options', options)
11 |     const {
12 |       name,
13 |       id,
14 |       num,
15 |       order_time,
16 |       nonce_str,
17 |     } = options
18 | 
19 |     this.setData({
20 |       name,
21 |       id,
22 |       num,
23 |       order_time,
24 |       nonce_str,
25 |     })
26 |   },
27 | 
28 |   linkDetail() {
29 |     const self = this
30 |     wx.navigateTo({
31 |       url: `/pages/detail/detail?id=${self.data.id}&order_id=${self.data.nonce_str}`
32 |     })
33 |   },
34 | })


--------------------------------------------------------------------------------
/app.wxss:
--------------------------------------------------------------------------------
 1 | page {
 2 |   min-height: 100%;
 3 |   box-sizing: border-box;
 4 |   background: #f5f6f6;
 5 |   font-family: "Helvetica Neue",Helvetica,"PingFang SC","Hiragino Sans GB","Microsoft YaHei","微软雅黑",Arial,sans-serif;
 6 | }
 7 | 
 8 | .bg-white {
 9 |   background: #fff;
10 | }
11 | 
12 | .pink { color: #e3007e !important; }
13 | .gray { color: #83889a !important; }
14 | 
15 | .tr { text-align: right !important; }
16 | .tc { text-align: center !important; }
17 | 
18 | .button {
19 |   display: block;
20 |   margin: 0 24rpx;
21 |   box-sizing: border-box;
22 |   border-radius: 24px;
23 |   height: 100rpx;
24 |   line-height: 100rpx;
25 |   background: #e3007e;
26 |   color: #fff;
27 |   font-size: 32rpx;
28 | }


--------------------------------------------------------------------------------
/pages/pay-success/pay-success.wxml:
--------------------------------------------------------------------------------
 1 | <view class="page">
 2 |   <view class="weui-msg">
 3 |     <view class="weui-msg__icon-area">
 4 |       <icon type="success" size="93"></icon>
 5 |     </view>
 6 | 
 7 |     <view class="weui-msg__text-area">
 8 |       <view class="weui-msg__title">支付成功</view>
 9 |       <view class="weui-msg__desc">
10 |         <text v-if="{{nonce_str}}">流水号：{{nonce_str}}</text>
11 |         <text>消费总金额：{{consume}}元</text>
12 |         <text>优惠券抵用：{{couponTotal}}元</text>
13 |         <text>实际支付：{{pay_sum}}元</text>
14 |       </view>
15 |     </view>
16 | 
17 |     <view class="weui-btn-area">
18 |       <button class="weui-btn" bindtap="linkIndexPage" type="primary">确定</button>
19 |     </view>
20 |   </view>
21 | </view>
22 | 


--------------------------------------------------------------------------------
/pages/detail/detail.js:
--------------------------------------------------------------------------------
 1 | import DetailModel from './detail-model'
 2 | import WxParse from '../../common/wxParse/wxParse'
 3 | const detailModel = new DetailModel()
 4 | 
 5 | const app = getApp()
 6 | Page({
 7 |   data:{
 8 |     wxParseData: '',
 9 |     id: '',
10 |     order_id: '',
11 |     item: {},
12 |   },
13 |   onLoad(options){
14 |     const { id = '', order_id = '' } = options
15 |     this.setData({
16 |       id,
17 |       order_id,
18 |     })
19 |     
20 |     this._fetchData()    
21 |   },
22 | 
23 |   _fetchData() {
24 |     const data = {
25 |       id: this.data.id,
26 |       order_id: this.data.order_id,
27 |     }
28 |     detailModel.getCouponDetailData(data, res => {
29 |       this.setData({
30 |         item: res.data,
31 |         wxParseData: WxParse.wxParse('article', 'html', res.data.details, this)
32 |       })
33 |     })
34 |   },
35 | })


--------------------------------------------------------------------------------
/common/coupon/index.wxss:
--------------------------------------------------------------------------------
 1 | .coupon {
 2 |   margin-bottom: 20rpx;
 3 |   display: flex; 
 4 |   width: 100%;
 5 |   height: 216rpx;
 6 | }
 7 | 
 8 | .used {
 9 |   background-image: url('https://gjb.demo.chilunyc.com/upload/weapp/coupon_used.jpg');
10 |   background-position: center;
11 |   background-repeat: no-repeat;
12 |   background-size: cover;
13 | }
14 | 
15 | .img {
16 |   margin: 32rpx;
17 |   width: 60rpx;
18 |   height: 60rpx;
19 |   border-radius: 50%;
20 |   border: 1rpx #ebecf1 solid;
21 | }
22 | 
23 | .hd {
24 |   flex: 1;
25 | }
26 | 
27 | .name {
28 |   margin-top: 24rpx;
29 |   display: block;
30 |   font-size: 28rpx;
31 |   color: #83889a;
32 | }
33 | 
34 | .price {
35 |   padding: 12rpx 0;
36 |   display: block;
37 |   font-size: 40rpx;
38 |   color: #28354c;
39 |   border-bottom: 1px #ebecf1 dashed;
40 | }
41 | 
42 | .desc {
43 |   margin-top: 10rpx;
44 |   display: block;
45 |   font-size: 28rpx;
46 |   color: #83889a;
47 | }


--------------------------------------------------------------------------------
/pages/before-pay/before-pay-model.js:
--------------------------------------------------------------------------------
 1 | import Base from '../../utils/base'
 2 | 
 3 | export default class BeforePayModel extends Base {
 4 |   constructor() {
 5 |     super()
 6 |   }
 7 | 
 8 |   checkIsBindPhone(successCb) {
 9 |     const params = {
10 |       type: 'POST',
11 |       url: 'users/check',
12 |       successCb,
13 |     }
14 | 
15 |     this.request(params)
16 |   }
17 | 
18 |   sendSmS(data, successCb) {
19 |     const params = {
20 |       type: 'POST',
21 |       url: 'sms',
22 |       data,
23 |       successCb,
24 |     }
25 | 
26 |     this.request(params)
27 |   }
28 | 
29 |   postUserInfo(data, successCb) {
30 |     const params = {
31 |       type: 'POST',
32 |       url: 'users',
33 |       data,
34 |       successCb,
35 |     }
36 | 
37 |     this.request(params)
38 |   }
39 | 
40 |   wxPay(data, successCb) {
41 |     const params = {
42 |       type: 'POST',
43 |       url: 'orders',
44 |       data,
45 |       successCb,
46 |     }
47 | 
48 |     this.request(params)
49 |   }
50 | }


--------------------------------------------------------------------------------
/pages/detail/detail.wxss:
--------------------------------------------------------------------------------
 1 | @import '../../common/coupon/index.wxss';
 2 | @import '../../common/wxParse/wxParse.wxss';
 3 | .coupon_detail {
 4 |   margin-bottom: 100rpx;
 5 |   padding:0 24rpx;
 6 |   width:100%;
 7 |   height:auto;
 8 |   box-sizing:border-box;
 9 | }
10 | 
11 | .coupon {
12 |   margin-top: 20rpx;
13 | }
14 | 
15 | .footer {
16 |   position: fixed;
17 |   bottom: 0;
18 |   right: 0;
19 |   display: flex;
20 |   height: 100rpx;
21 |   line-height: 100rpx;
22 |   width: 100%;
23 | }
24 | 
25 | .footer_left {
26 |   padding-left: 24rpx;
27 |   width: 64%;
28 |   height: inherit;
29 |   background: #fff;
30 |   color: #e3007e;
31 |   font-size: 28rpx;
32 | }  
33 | 
34 | .price_footer {
35 |   font-size: 40rpx !important;
36 | }
37 |   
38 | .footer_right {
39 |   width: 36%;
40 |   height: inherit;
41 |   background: #e3007e;
42 |   font-size: 32rpx;
43 |   color: #fff;
44 |   text-align: center;
45 | }
46 | 
47 | .used_btn {
48 |   width: 36%;
49 |   height: inherit;
50 |   background: #c4c5ce;
51 |   font-size: 32rpx;
52 |   color: #fff;
53 |   text-align: center;
54 | }


--------------------------------------------------------------------------------
/pages/after-pay/after-pay.wxss:
--------------------------------------------------------------------------------
 1 | .container {
 2 |   margin-top: 20rpx;
 3 |   font-size: 28rpx;
 4 | }
 5 | 
 6 | .cell_box {
 7 |   display: flex;
 8 |   padding: 0 24rpx;
 9 |   width: 100%;
10 |   height: 80rpx;
11 |   box-sizing: border-box;
12 |   background: #fff;
13 |   line-height: 80rpx;
14 |   border-bottom: 1px #ebecf1 solid; 
15 |   overflow: hidden;
16 | }
17 | 
18 | .cell_bd {
19 |   flex: 1;
20 |   height: inherit;
21 |   color: #83889a;
22 | }
23 | 
24 | .cell_ft {
25 |   height: inherit;  
26 |   color: #28354c;
27 |   text-align: right;
28 |   flex: 2;
29 |   display: flex;
30 |   align-items: center;
31 |   justify-content: flex-end;
32 | }
33 | 
34 | .tips_box {
35 |   margin-top: 20rpx;
36 |   padding: 24rpx;
37 |   box-sizing: border-box;
38 |   background: #fff;
39 |   font-size: 12px;
40 |   color: #83889A;
41 |   line-height: 40rpx;
42 |   width: 100%;
43 |   height: auto;
44 | }
45 | 
46 | .title {
47 |   display: block;
48 |   margin-bottom: 20rpx;
49 |   font-size: 28rpx;
50 |   color: #28354C;
51 | }
52 | 
53 | .tips {
54 |   padding-left: 26rpx;
55 |   margin-bottom: 10rpx;
56 | }
57 | 
58 | .ol {
59 |   position: absolute;
60 |   left: 20rpx;
61 | }
62 | 
63 | .button {
64 |   margin-top: 100rpx;
65 | }


--------------------------------------------------------------------------------
/pages/after-pay/after-pay.wxml:
--------------------------------------------------------------------------------
 1 | <view class="container">
 2 |   <view class="cell_box">
 3 |     <view class="cell_bd">优惠券</view>
 4 |     <view class="cell_ft">{{name}}</view>
 5 |   </view>
 6 | 
 7 |   <view class="cell_box">
 8 |     <view class="cell_bd">数量</view>
 9 |     <view class="cell_ft">{{num}}</view>
10 |   </view>
11 | 
12 |   <view class="cell_box">
13 |     <view class="cell_bd">购买时间</view>
14 |     <view class="cell_ft">{{order_time}}</view>
15 |   </view>
16 | 
17 |   <view class="cell_box">
18 |     <view class="cell_bd">订单编号</view>
19 |     <view class="cell_ft">{{nonce_str}}</view>
20 |   </view>
21 | 
22 |   <view class="tips_box">
23 |     <text class="title">如何使用优惠券？</text>
24 |     <view class="tips">
25 |       <text class="ol">1.</text>
26 |       <text>微信扫一扫商家收银台的“逛街宝收款二维码”</text>
27 |     </view>
28 |     <view class="tips">
29 |       <text class="ol">2.</text>
30 |       <text>输入您本次的消费金额，如果您当前拥有该商家的可用优惠券，逛街宝将自动为您匹配</text>
31 |     </view>
32 |     <view class="tips">
33 |       <text class="ol">3.</text>
34 |       <text>选择您要使用的优惠券</text>
35 |     </view>
36 |     <view class="tips">
37 |       <text class="ol">4.</text>
38 |       <text>您只要支付只用用回去抵用之后的剩余金额即可</text>
39 |     </view>
40 |   </view>
41 | 
42 |   <button class="button" bindtap="linkDetail">查看优惠券</button>
43 | </view>
44 | 


--------------------------------------------------------------------------------
/pages/detail/detail.wxml:
--------------------------------------------------------------------------------
 1 | <view class="coupon_detail">
 2 |   <view class="coupon {{item.status ? 'used' : 'bg-white'}}">
 3 |     <image class="img" src="{{item.logo}}" mode="aspectFill"></image>
 4 |     <view class="hd">
 5 |       <text class="name">{{item.merchant_name}}</text>
 6 |       <text class="price">{{item.coupon_name}}</text>
 7 |       <text class="desc">{{item.price}} 元代 {{item.face_value}} 元</text>
 8 |     </view>
 9 |   </view>
10 | 
11 |   <import src="../../common/wxParse/wxParse.wxml"/>
12 |   <template is="wxParse" data="{{wxParseData:article.nodes}}"/>
13 | 
14 |   <view class="footer">
15 |     <view class="footer_left">
16 |       <text>￥</text>
17 |       <text class="price_footer">{{item.price}}</text>
18 |       <text>.00</text>
19 |       <text class="gray">（{{item.price}} 元代 {{item.face_value}} 元）</text>
20 |     </view>
21 |    
22 |     <view wx:if="{{item.status == 0}}" class="footer_right">
23 |       <text>待消费</text>
24 |     </view>
25 |     <view wx:elif="{{item.status == 1}}" class="used_btn">
26 |       <text>已使用</text>
27 |     </view>
28 |     <navigator wx:else class="footer_right" url="../before-pay/before-pay?name={{item.merchant_name}}&price={{item.price}}&id={{item.id}}" open-type="navigateTo">
29 |       <text>购买</text>
30 |     </navigator>
31 |   </view>
32 | </view>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # mall-coupons
 2 | - 为商场购物的顾客以及商家提供的优惠券小程序
 3 | - 用户可以在商场的大屏幕或者其他海报上扫描二维码，打开小程序购买对应的优惠券
 4 | - 在支持优惠券的商家扫描二维码，打开小程序使用优惠券抵扣消费金额
 5 | 
 6 | ## token 令牌维护机制
 7 | ![token](https://ws1.sinaimg.cn/large/006tNc79ly1fhuqb7porej317s0pan1d.jpg)
 8 | 具体代码实现请看 `/utlis/token.js`
 9 | 
10 | ## 页面介绍
11 | ### 用户的优惠券列表页↓
12 | - URL: `pages/home/home` 
13 | - <img src="https://ws3.sinaimg.cn/large/006tNc79ly1fhjfy8axygj30ki0vg40s.jpg" width="450" />
14 | 
15 | ### 优惠券详情页↓
16 | - URL: `pages/detail/detail`
17 | - <img src="https://ws4.sinaimg.cn/large/006tNc79ly1fhjfzoj6dzj30ku0zqq8e.jpg" width="450" />
18 | 
19 | ### 购买优惠券页↓
20 | - URL: `pages/before-pay/before-pay`
21 | - <img src="https://ws2.sinaimg.cn/large/006tNc79ly1fhjg22bk0qj30kw0li759.jpg" width="450" />
22 | 
23 | ### 优惠券支付完成页↓
24 | - URL: `pages/after-pay/after-pay`
25 | - <img src="https://ws4.sinaimg.cn/large/006tNc79ly1fhjg35gpc1j30ks0rudi4.jpg" width="450" />
26 | 
27 | ### 扫码商家的二维码，优惠券抵扣消费金额页面↓
28 | - URL: `pages/qr-pay/qr-pay`
29 | - <img src="https://ws1.sinaimg.cn/large/006tNc79ly1fhjg4dhddxj30ki0xo76j.jpg" width="450" />
30 | 
31 | ### 消费成功页面↓
32 | - URL: `pages/pay-success/pay-success` 
33 | - <img src="https://ws4.sinaimg.cn/large/006tNc79ly1fhjg557vnej30ky0nwq46.jpg" width="450" />
34 | 
35 | 
36 | ## 感谢第三方库
37 | [wxParse](微信小程序富文本解析自定义组件)
38 | 
39 | ## TODO
40 | - model.js 虽然做到了 views 和 model 的分离，但是当 ajax 发生错误时的判断没有交给 model.js 来处理，而是不恰当的放到 views 里判断了。
41 | model.js 应该再过滤和判断一下数据，让 views 只需要拿到自己想到数据，不需要做其他的事。
42 | 
43 | - 使用优惠券抵用消费金额时，当总优惠的金额大于消费金额时，应该提示用户
44 | 


--------------------------------------------------------------------------------
/pages/before-pay/before-pay.wxml:
--------------------------------------------------------------------------------
 1 | <view class="container">
 2 |   <view class="cell_box">
 3 |     <view class="cell_bd">{{name}}</view>
 4 |     <view class="cell_ft">{{price}}元</view>
 5 |   </view>
 6 | 
 7 |   <view class="cell_box">
 8 |     <view class="cell_bd">数量</view>
 9 |     <view class="cell_ft">
10 |       <view class="computed_btn" bindtap="subtractNum">-</view>
11 |       <text class="num">{{num}}</text>
12 |       <view class="computed_btn" bindtap="addNum">+</view>
13 |     </view>
14 |   </view>
15 | 
16 |   <view class="cell_box">
17 |     <view class="cell_bd">小计</view>
18 |     <view class="cell_ft">￥ {{price * num}}</view>
19 |   </view>
20 | 
21 |   <view wx-if="{{!isBindPhone}}">
22 |     <view class="cell_box cell_phone">
23 |       <view class="cell_bd_phone">手机号</view>
24 |       <view class="cell_ft_input">
25 |         <input placeholder="请输入手机号" bindinput="bindPhone" placeholder-style="color: #c4c5ce" type="number"	/>
26 |       </view>
27 |     </view>
28 | 
29 |     <view class="cell_box cell_code">
30 |       <view class="cell_bd_phone">验证码</view>
31 |       <view class="cell_ft_input_code">
32 |         <input placeholder="请输入验证码" bindinput="bindCode" placeholder-style="color: #c4c5ce" type="number"	/>
33 |       </view>
34 |       <view wx:if="{{!isSendMsging}}" class="send_code pink" bindtap="sendSmS">发送</view>
35 |       <view wx:else class="send_code">{{timeOut}} 秒</view>
36 |     </view>
37 |   </view>
38 | 
39 |   <button class="button" bindtap="submitPay">微信支付</button>
40 | </view>
41 | 


--------------------------------------------------------------------------------
/utils/base.js:
--------------------------------------------------------------------------------
 1 | import Token from './token'
 2 | import Config from './config'
 3 | 
 4 | export default class Base {
 5 |   constructor() {
 6 |     this.baseUrl = Config.baseUrl
 7 |   }
 8 | 
 9 |   /*
10 |    *  http 请求类
11 |    * @isRefetch 为 false 时，不做未授权重试机制
12 |    */
13 |   request(params, isRefetch = true) {
14 |     const url = this.baseUrl + params.url
15 |     const self = this
16 | 
17 |     wx.request({
18 |       url,
19 |       data: params.data,
20 |       method: params.type || 'GET',
21 |       header: {
22 |         'Authorization': 'Bearer ' + wx.getStorageSync('token'),
23 |         'Accept': 'application/json'
24 |       },
25 |       success(res) {
26 |         // 判断以2（2xx)开头的状态码为正确
27 |         // 异常不要返回到回调中，就在request中处理，记录日志并showToast一个统一的错误即可
28 |         const codeStartChar = res.statusCode.toString().charAt(0)
29 |         if(codeStartChar == '2') {
30 |           typeof params.successCb == 'function' && params.successCb(res.data)
31 |         } else if (codeStartChar == '4' && isRefetch) {
32 |           // 如果 token 检测失败，那么还有、仅有一次获取新的 token ，重新请求的机会
33 |           self._refetch(params)
34 |         } else {
35 |           self._processError(res.data)
36 |           typeof params.errorCb == 'function' && params.errorCb(res.data)
37 |         }
38 |       },
39 |     })
40 |   }
41 | 
42 |   // 未授权重试机制，当检测为 401 时，获取新的 token，然后重新发起对应的请求
43 |   // 为了防止无限循环，只重新发起一次请求
44 |   _refetch(params) {
45 |     const token = new Token()
46 |     token.getTokenFromServer(token => this.request(params, false))
47 |   }
48 | 
49 |   _processError(err) {
50 |     console.log(err)
51 |   }
52 | 
53 |   getDataSet(event, key) {
54 |     return event.currentTarget.dataset[key]
55 |   }
56 | }


--------------------------------------------------------------------------------
/utils/token.js:
--------------------------------------------------------------------------------
 1 | import Config from './config'
 2 | 
 3 | export default class Token {
 4 |   constructor() {
 5 |     this.verifyUrl = Config.baseUrl + 'token/verify'
 6 |     this.tokenUrl = Config.baseUrl + 'users/login'
 7 |   }
 8 | 
 9 |   verify() {
10 |     const self = this
11 |     wx.getStorage({
12 |       key: 'token',
13 |       success(res) {
14 |         self._verifyFromServer(res.data)
15 |       },
16 |       fail() {
17 |         self.getTokenFromServer()
18 |       }
19 |     })
20 |   }
21 | 
22 |   //验证 token 是否过期
23 |   _verifyFromServer(token) {
24 |     const self = this
25 |     wx.request({
26 |       url: self.verifyUrl,
27 |       header: {
28 |         'Authorization': 'Bearer ' + token,
29 |         'Accept': 'application/json'
30 |       },
31 |       success(res){
32 |         if(res.statusCode == 401) {
33 |           self.getTokenFromServer()
34 |         }
35 |       },
36 |       fail() {
37 |       },
38 |     })
39 |   }
40 | 
41 |   //获取新的 token
42 |   getTokenFromServer(callBack) {
43 |     const self = this
44 |     wx.login({  
45 |       success(res_code) {
46 |         if (res_code.code) {
47 |           wx.request({
48 |             url: self.tokenUrl,
49 |             method: 'POST',
50 |             data: {
51 |               code: res_code.code
52 |             },
53 |             success(res) {
54 |               wx.setStorageSync('token', res.data.data.token)
55 |               typeof callBack == 'function' && callBack(res.data.data.token)
56 |             },
57 |             fail() {
58 |               wx.showToast({title: '网络错误，请重新授权！'})
59 |             },
60 |           })
61 |         } else {
62 |           console.log('获取用户登录态失败！' + res.errMsg)
63 |         }
64 |       }
65 |     })
66 |   }
67 | }


--------------------------------------------------------------------------------
/pages/qr-pay/qr-pay.wxml:
--------------------------------------------------------------------------------
 1 | <view class="container">
 2 |   <view class="header">
 3 |     <view class="media">
 4 |       <image class="shop_img" src="{{merchant_info.logo}}" mode="aspectFill"></image>
 5 |       <text class="shop_name">{{merchant_info.name}}</text>
 6 |     </view>
 7 | 
 8 |     <view class="ipt_box">
 9 |       <input placeholder-style="color: #c4c5ce" bindinput="bindConsume" placeholder="请输入消费金额" type="digit" />
10 |     </view>
11 |   </view>
12 | 
13 |   <checkbox-group bindchange="checkboxChange" class="coupon_list">
14 |     <text class="coupon_num">您有 {{coupons.length}} 张可用优惠券</text>
15 | 
16 |     <view class="coupon" wx:for="{{coupons}}" wx:key>
17 |       <image class="shop_img" src="{{merchant_info.logo}}" mode="aspectFill"></image>
18 |       <text class="coupon_name">{{item.name}}</text>
19 |       <text class="pink">-{{item.face_value}}</text>
20 |       <label class="weui-cell weui-check__label" wx:key="value">
21 |         <checkbox class="weui-check" value="{{index}}" checked="{{item.isSeleted}}"/>
22 |         <view class="weui-cell__hd weui-check__hd_in-checkbox">
23 |           <icon class="weui-icon-checkbox_circle" type="circle" size="23" wx:if="{{!item.isSeleted}}"></icon>
24 |           <icon class="weui-icon-checkbox_success" type="success" size="23" wx:if="{{item.isSeleted}}"></icon>
25 |         </view>
26 |       </label>
27 |     </view>
28 | 
29 |   </checkbox-group>
30 | 
31 |   <view class="cell_box">
32 |     <view class="cell_bd">优惠券抵用：</view>
33 |     <view class="cell_ft" wx:if="{{couponTotal}}">-{{couponTotal}}</view>
34 |     <view class="cell_ft" wx:else>无</view>
35 |   </view>
36 | 
37 |   <view class="cell_box">
38 |     <view class="cell_bd">您还需支付：</view>
39 |     <view class="cell_ft">￥{{pay_sum}}</view>
40 |   </view>
41 | 
42 |   <button class="button" bindtap="submitPay">微信支付</button>
43 | </view>


--------------------------------------------------------------------------------
/pages/before-pay/before-pay.wxss:
--------------------------------------------------------------------------------
  1 | .container {
  2 |   margin-top: 20rpx;
  3 |   font-size: 28rpx;
  4 | }
  5 | 
  6 | .cell_box {
  7 |   display: flex;
  8 |   padding: 0 24rpx;
  9 |   width: 100%;
 10 |   height: 80rpx;
 11 |   box-sizing: border-box;
 12 |   background: #fff;
 13 |   line-height: 80rpx;
 14 |   border-bottom: 1px #ebecf1 solid; 
 15 |   overflow: hidden;
 16 | }
 17 | 
 18 | .cell_bd {
 19 |   flex: 3;
 20 |   height: inherit;
 21 |   color: #83889a;
 22 | }
 23 | 
 24 | .cell_ft {
 25 |   height: inherit;  
 26 |   color: #28354c;
 27 |   text-align: right;
 28 |   flex: 2;
 29 |   display: flex;
 30 |   align-items: center;
 31 |   justify-content: flex-end;
 32 | }
 33 | 
 34 | .num {
 35 |   margin: 0 10rpx;
 36 |   padding: 0 30rpx;
 37 |   display: block;
 38 |   height: 52rpx;
 39 |   line-height: 52rpx;
 40 |   text-align: center;
 41 |   background: #EBECF1;
 42 | }
 43 | 
 44 | .computed_btn {
 45 |   height: 52rpx;
 46 |   width: 52rpx;
 47 |   line-height: 52rpx;
 48 |   text-align: center;
 49 |   border-radius: 0;
 50 |   font-size: 32rpx;
 51 |   color: #83889a;
 52 |   background: #EBECF1;
 53 | }
 54 | 
 55 | .cell_phone {
 56 |   margin-top: 20rpx;
 57 | }
 58 | 
 59 | .cell_bd_phone {
 60 |   flex: 1;
 61 |   height: inherit;
 62 |   color: #83889a;
 63 | }
 64 | 
 65 | .cell_ft_input {
 66 |   height: inherit;  
 67 |   color: #28354c;
 68 |   text-align: right;
 69 |   flex: 3;
 70 |   display: flex;
 71 |   align-items: center;
 72 | }
 73 | 
 74 | .cell_ft_input input {
 75 |   text-align: left;
 76 |   width: 100%;
 77 |   height: inherit;
 78 | }
 79 | 
 80 | .cell_ft_input_code {
 81 |   height: inherit;  
 82 |   color: #28354c;
 83 |   text-align: right;
 84 |   flex: 2;
 85 |   display: flex;
 86 |   align-items: center;
 87 | }
 88 | 
 89 | .cell_ft_input_code input {
 90 |   text-align: left;
 91 |   width: 100%;
 92 | }
 93 | 
 94 | .send_code {
 95 |   flex: 1;
 96 |   border-left: 1px #ebecf1 solid;
 97 |   text-align: center;
 98 |   height: inherit;
 99 | }
100 | 
101 | .button {
102 |   margin-top: 100rpx;
103 | }


--------------------------------------------------------------------------------
/pages/qr-pay/qr-pay.js:
--------------------------------------------------------------------------------
  1 | import QrPayModel from './qr-pay-model'
  2 | const qrPayModel = new QrPayModel()
  3 | 
  4 | Page({
  5 |   data:{
  6 |     consume: 0, // 用户输入的消费额度
  7 |     merchant_id: 1, // 商家 id
  8 |     merchant_info: {},
  9 |     coupons: [], // 优惠券列表
 10 |     couponTotal: 0, // 优惠券一共抵用了多少钱
 11 |     pay_sum: 0, // 需要支付的金额
 12 |   },
 13 |   onLoad(query){
 14 |     const { merchant_id = 1 } = query
 15 | 
 16 |     this.setData({
 17 |       merchant_id
 18 |     })
 19 | 
 20 |     this._getMerchantsInfo(merchant_id)
 21 |   },
 22 | 
 23 |   _getMerchantsInfo(merchant_id) {
 24 |     qrPayModel.getMerchantsInfo(merchant_id, res => {
 25 |       if(res.data) {
 26 |         const result = res.data
 27 |         let { coupons = [] } = result
 28 |         // TODO 再 forEach 一个 disabled: false 字段
 29 |         coupons.forEach(item => item.isSeleted = false)
 30 |         this.setData({
 31 |           merchant_info: {
 32 |             logo: result.logo,
 33 |             name: result.name,
 34 |           },
 35 |           coupons,
 36 |         })
 37 |       }
 38 |     })
 39 |   },
 40 | 
 41 |   bindConsume(e) {
 42 |     // TODO 用户改变输入的消费额度时，要判断消费额度是否大于当前已选择的优惠券总额
 43 |     const consume = Number(e.detail.value.trim())
 44 |     const couponTotal = this.data.coupons.reduce((total,prev) => total + prev.face_value * Number(prev.isSeleted), 0)
 45 |     const pay_sum = Number((consume - couponTotal < 0 ? 0 : consume - couponTotal).toFixed(1))
 46 |     this.setData({
 47 |       consume,
 48 |       pay_sum,
 49 |     })
 50 |   },
 51 | 
 52 |   checkboxChange(e) {
 53 |     // TODO 防止出现用户多用了优惠券的情况
 54 |     let { coupons } = this.data
 55 |     coupons.forEach(item => item.isSeleted = false)
 56 |     e.detail.value.forEach(index => {
 57 |       coupons[Number(index)].isSeleted = true
 58 |     })
 59 |     const couponTotal = coupons.reduce((total,prev) => total + prev.face_value * Number(prev.isSeleted), 0)
 60 |     const pay_sum = Number((this.data.consume - couponTotal < 0 ? 0 : this.data.consume - couponTotal).toFixed(1))
 61 | 
 62 |     //TODO 用户选择的优惠券总额大于 用户输入的消费额度 时，禁止用户再添加优惠券
 63 |     // if(couponTotal >= this.data.consume) {
 64 |     //   coupons.forEach(item => item.disabled = true)
 65 |     // }
 66 | 
 67 |     this.setData({
 68 |       coupons,
 69 |       couponTotal,
 70 |       pay_sum,
 71 |     })
 72 |   },
 73 | 
 74 |   submitPay() {
 75 |     if(!this.data.consume) {
 76 |       wx.showModal({
 77 |         title: '请输入消费金额！',
 78 |         content: '',
 79 |         showCancel: false,
 80 |       })
 81 |       return 
 82 |     }
 83 |     
 84 |     this._wxPay()
 85 |   },
 86 |   
 87 |   _wxPay(token) {
 88 |     const ids = this.data.coupons.filter(coupon => coupon.isSeleted).map(coupon => coupon.order_id).join()    
 89 |     const data = {
 90 |       ids,
 91 |       merchant_id: this.data.merchant_id,
 92 |       consume: this.data.consume,
 93 |       pay_sum: this.data.pay_sum,
 94 |     }
 95 |     qrPayModel.wxPay(data, res => {
 96 |       if(!res.data) {
 97 |          wx.showModal({
 98 |           title: '支付失败，请退出重试！',
 99 |           content: '',
100 |           showCancel: false,
101 |         })
102 |         return
103 |       }
104 |       const payData = res.data
105 |       console.log(payData)
106 |       if(payData.status === 1) {
107 |         // 不需要调用支付
108 |         console.log(`/pages/pay-success/pay-success?consume=${this.data.consume}&couponTotal=${this.data.couponTotal}&pay_sum=${this.data.pay_sum}`)
109 |         wx.redirectTo({
110 |           url: `/pages/pay-success/pay-success?consume=${this.data.consume}&couponTotal=${this.data.couponTotal}&pay_sum=${this.data.pay_sum}`
111 |         })
112 |       } else if (payData.appid && payData.pay_sign) {
113 |         // 需要调用微信支付
114 |         const {
115 |           appid,
116 |           timestamp,
117 |           nonce_str,
118 |           pack_age,
119 |           sign_type,
120 |           pay_sign,
121 |           order_time
122 |         } = payData
123 | 
124 |         const self = this
125 |         wx.requestPayment({
126 |           timeStamp: timestamp,
127 |           nonceStr: nonce_str,
128 |           package: pack_age,
129 |           signType: 'MD5',
130 |           paySign: pay_sign,
131 |           success(res_pay){
132 |             console.log(`/pages/pay-success/pay-success?nonce_str=${nonce_str}&consume=${self.data.consume}&couponTotal=${self.data.couponTotal}&pay_sum=${self.data.pay_sum}`)
133 |             wx.redirectTo({
134 |               url: `/pages/pay-success/pay-success?nonce_str=${nonce_str}&consume=${self.data.consume}&couponTotal=${self.data.couponTotal}&pay_sum=${self.data.pay_sum}`
135 |             })
136 |           },
137 |           fail(res_pay){
138 |             wx.showModal({
139 |               title: '支付失败，请重试！',
140 |               content: '',
141 |               showCancel: false,
142 |             })
143 |           }
144 |         })
145 |       }  
146 |     })
147 |   },
148 | })


--------------------------------------------------------------------------------
/common/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: Helvetica,sans-serif;
 16 |     font-size: 28rpx;
 17 |     color: #666;
 18 |     line-height: 1.8;
 19 |     background: #fff;
 20 | }
 21 | view{
 22 |     word-break:break-all; overflow:auto;
 23 | }
 24 | .wxParse-inline{
 25 |     display: inline;
 26 |     margin: 0;
 27 |     padding: 0;
 28 | }
 29 | /*//标题 */
 30 | .wxParse-div{margin: 0;padding: 0;}
 31 | .wxParse-h1{ font-size:2em; margin: .67em 0 }
 32 | .wxParse-h2{ font-size:1.5em; margin: .75em 0 }
 33 | .wxParse-h3{ font-size:1.17em; margin: .83em 0 }
 34 | .wxParse-h4{ margin: 1.12em 0}
 35 | .wxParse-h5 { font-size:.83em; margin: 1.5em 0 }
 36 | .wxParse-h6{ font-size:.75em; margin: 1.67em 0 }
 37 | 
 38 | .wxParse-h1 {
 39 |   font-size: 18px;
 40 |   font-weight: 400;
 41 |   margin-bottom: .9em;
 42 | }
 43 | .wxParse-h2 {
 44 |   font-size: 16px;
 45 |   font-weight: 400;
 46 |   margin-bottom: .34em;
 47 | }
 48 | .wxParse-h3 {
 49 |   font-weight: 400;
 50 |   font-size: 15px;
 51 |   margin-bottom: .34em;
 52 | }
 53 | .wxParse-h4 {
 54 |   font-weight: 400;
 55 |   font-size: 14px;
 56 |   margin-bottom: .24em;
 57 | }
 58 | .wxParse-h5 {
 59 |   font-weight: 400;
 60 |   font-size: 13px;
 61 |   margin-bottom: .14em;
 62 | }
 63 | .wxParse-h6 {
 64 |   font-weight: 400;
 65 |   font-size: 12px;
 66 |   margin-bottom: .04em;
 67 | }
 68 | 
 69 | .wxParse-h1, .wxParse-h2, .wxParse-h3, .wxParse-h4, .wxParse-h5, .wxParse-h6, .wxParse-b, .wxParse-strong  { font-weight: bolder }
 70 | 
 71 | .wxParse-i,.wxParse-cite,.wxParse-em,.wxParse-var,.wxParse-address{font-style:italic}
 72 | .wxParse-pre,.wxParse-tt,.wxParse-code,.wxParse-kbd,.wxParse-samp{font-family:monospace}
 73 | .wxParse-pre{white-space:pre}
 74 | .wxParse-big{font-size:1.17em}
 75 | .wxParse-small,.wxParse-sub,.wxParse-sup{font-size:.83em}
 76 | .wxParse-sub{vertical-align:sub}
 77 | .wxParse-sup{vertical-align:super}
 78 | .wxParse-s,.wxParse-strike,.wxParse-del{text-decoration:line-through}
 79 | /*wxparse-自定义个性化的css样式*/
 80 | /*增加video的css样式*/
 81 | .wxParse-strong,.wxParse-s{display: inline}
 82 | .wxParse-a{
 83 |     color: deepskyblue;
 84 |     word-break:break-all;
 85 |     overflow:auto;
 86 | }
 87 | 
 88 | .wxParse-video{
 89 |     text-align: center;
 90 |     margin: 10px 0;
 91 | }
 92 | 
 93 | .wxParse-video-video{
 94 |     width:100%;
 95 | }
 96 | 
 97 | .wxParse-img{
 98 |     /*background-color: #efefef;*/
 99 |     overflow: hidden;
100 | }
101 | 
102 | .wxParse-blockquote {
103 |     margin: 0;
104 |     padding:10px 0 10px 5px;
105 |     font-family:Courier, Calibri,"宋体";
106 |     background:#f5f5f5;
107 |     border-left: 3px solid #dbdbdb;
108 | }
109 | 
110 | .wxParse-code,.wxParse-wxxxcode-style{
111 |     display: inline;
112 |     background:#f5f5f5;
113 | }
114 | .wxParse-ul{
115 |     margin: 20rpx 10rpx;
116 | }
117 | 
118 | .wxParse-li,.wxParse-li-inner{
119 |     display: flex;
120 |     align-items: baseline;
121 |     margin: 10rpx 0;
122 | }
123 | .wxParse-li-text{
124 |     
125 |     align-items: center;
126 |     line-height: 20px;
127 | }
128 | 
129 | .wxParse-li-circle{
130 |     display: inline-flex;
131 |     width: 5px;
132 |     height: 5px;
133 |     background-color: #333;
134 |     margin-right: 5px;
135 | }
136 | 
137 | .wxParse-li-square{
138 |     display: inline-flex;
139 |     width: 10rpx;
140 |     height: 10rpx;
141 |     background-color: #333;
142 |     margin-right: 5px;
143 | }
144 | .wxParse-li-ring{
145 |     display: inline-flex;
146 |     width: 10rpx;
147 |     height: 10rpx;
148 |     border: 2rpx solid #333;
149 |     border-radius: 50%;
150 |     background-color: #fff;
151 |     margin-right: 5px;
152 | }
153 | 
154 | /*.wxParse-table{
155 |     width: 100%;
156 |     height: 400px;
157 | }
158 | .wxParse-thead,.wxParse-tfoot,.wxParse-tr{
159 |     display: flex;
160 |     flex-direction: row;
161 | }
162 | .wxParse-th,.wxParse-td{
163 |     display: flex;
164 |     width: 580px;
165 |     overflow: auto;
166 | }*/
167 | 
168 | .wxParse-u {
169 |   text-decoration: underline;
170 | }
171 | .wxParse-hide{
172 |     display: none;
173 | }
174 | .WxEmojiView{
175 |     align-items: center;
176 | }
177 | .wxEmoji{
178 |     width: 16px;
179 |     height:16px;
180 | }
181 | .wxParse-tr{
182 | 	display: flex;
183 | 	border-right:1px solid #e0e0e0;
184 | 	border-bottom:1px solid #e0e0e0;
185 | 	border-top:1px solid #e0e0e0;
186 | }
187 | .wxParse-th,
188 | .wxParse-td{
189 | 	flex:1;
190 | 	padding:5px;
191 | 	font-size:28rpx;
192 | 	border-left:1px solid #e0e0e0;
193 | 	word-break: break-all;
194 | }
195 | .wxParse-td:last{
196 | 	border-top:1px solid #e0e0e0;
197 | }
198 | .wxParse-th{
199 | 	background:#f0f0f0;
200 | 	border-top:1px solid #e0e0e0;
201 | }
202 | .wxParse-del{
203 |     display: inline;
204 | }
205 | 


--------------------------------------------------------------------------------
/common/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 |  * utils函数引入
 14 |  **/
 15 | import showdown from './showdown.js';
 16 | import HtmlToJson from './html2json.js';
 17 | /**
 18 |  * 配置及公有属性
 19 |  **/
 20 | var realWindowWidth = 0;
 21 | var realWindowHeight = 0;
 22 | wx.getSystemInfo({
 23 |   success: function (res) {
 24 |     realWindowWidth = res.windowWidth
 25 |     realWindowHeight = res.windowHeight
 26 |   }
 27 | })
 28 | /**
 29 |  * 主函数入口区
 30 |  **/
 31 | function wxParse(bindName = 'wxParseData', type='html', data='<div class="color:red;">数据不能为空</div>', target,imagePadding) {
 32 |   var that = target;
 33 |   var transData = {};//存放转化后的数据
 34 |   if (type == 'html') {
 35 |     transData = HtmlToJson.html2json(data, bindName);
 36 |     // console.log(JSON.stringify(transData, ' ', ' '));
 37 |   } else if (type == 'md' || type == 'markdown') {
 38 |     var converter = new showdown.Converter();
 39 |     var html = converter.makeHtml(data);
 40 |     transData = HtmlToJson.html2json(html, bindName);
 41 |     console.log(JSON.stringify(transData, ' ', ' '));
 42 |   }
 43 |   transData.view = {};
 44 |   transData.view.imagePadding = 0;
 45 |   if(typeof(imagePadding) != 'undefined'){
 46 |     transData.view.imagePadding = imagePadding
 47 |   }
 48 |   var bindData = {};
 49 |   bindData[bindName] = transData;
 50 |   that.setData(bindData)
 51 |   that.wxParseImgLoad = wxParseImgLoad;
 52 |   that.wxParseImgTap = wxParseImgTap;
 53 | }
 54 | // 图片点击事件
 55 | function wxParseImgTap(e) {
 56 |   var that = this;
 57 |   var nowImgUrl = e.target.dataset.src;
 58 |   var tagFrom = e.target.dataset.from;
 59 |   if (typeof (tagFrom) != 'undefined' && tagFrom.length > 0) {
 60 |     wx.previewImage({
 61 |       current: nowImgUrl, // 当前显示图片的http链接
 62 |       urls: that.data[tagFrom].imageUrls // 需要预览的图片http链接列表
 63 |     })
 64 |   }
 65 | }
 66 | 
 67 | /**
 68 |  * 图片视觉宽高计算函数区 
 69 |  **/
 70 | function wxParseImgLoad(e) {
 71 |   var that = this;
 72 |   var tagFrom = e.target.dataset.from;
 73 |   var idx = e.target.dataset.idx;
 74 |   if (typeof (tagFrom) != 'undefined' && tagFrom.length > 0) {
 75 |     calMoreImageInfo(e, idx, that, tagFrom)
 76 |   } 
 77 | }
 78 | // 假循环获取计算图片视觉最佳宽高
 79 | function calMoreImageInfo(e, idx, that, bindName) {
 80 |   var temData = that.data[bindName];
 81 |   if (!temData || temData.images.length == 0) {
 82 |     return;
 83 |   }
 84 |   var temImages = temData.images;
 85 |   //因为无法获取view宽度 需要自定义padding进行计算，稍后处理
 86 |   var recal = wxAutoImageCal(e.detail.width, e.detail.height,that,bindName); 
 87 |   // temImages[idx].width = recal.imageWidth;
 88 |   // temImages[idx].height = recal.imageheight; 
 89 |   // temData.images = temImages;
 90 |   // var bindData = {};
 91 |   // bindData[bindName] = temData;
 92 |   // that.setData(bindData);
 93 |   var index = temImages[idx].index
 94 |   var key = `${bindName}`
 95 |   for (var i of index.split('.')) key+=`.nodes[${i}]`
 96 |   var keyW = key + '.width'
 97 |   var keyH = key + '.height'
 98 |   that.setData({
 99 |     [keyW]: recal.imageWidth,
100 |     [keyH]: recal.imageheight,
101 |   })
102 | }
103 | 
104 | // 计算视觉优先的图片宽高
105 | function wxAutoImageCal(originalWidth, originalHeight,that,bindName) {
106 |   //获取图片的原始长宽
107 |   var windowWidth = 0, windowHeight = 0;
108 |   var autoWidth = 0, autoHeight = 0;
109 |   var results = {};
110 |   var padding = that.data[bindName].view.imagePadding;
111 |   windowWidth = realWindowWidth-2*padding;
112 |   windowHeight = realWindowHeight;
113 |   //判断按照那种方式进行缩放
114 |   // console.log("windowWidth" + windowWidth);
115 |   if (originalWidth > windowWidth) {//在图片width大于手机屏幕width时候
116 |     autoWidth = windowWidth;
117 |     // console.log("autoWidth" + autoWidth);
118 |     autoHeight = (autoWidth * originalHeight) / originalWidth;
119 |     // console.log("autoHeight" + autoHeight);
120 |     results.imageWidth = autoWidth;
121 |     results.imageheight = autoHeight;
122 |   } else {//否则展示原来的数据
123 |     results.imageWidth = originalWidth;
124 |     results.imageheight = originalHeight;
125 |   }
126 |   return results;
127 | }
128 | 
129 | function wxParseTemArray(temArrayName,bindNameReg,total,that){
130 |   var array = [];
131 |   var temData = that.data;
132 |   var obj = null;
133 |   for(var i = 0; i < total; i++){
134 |     var simArr = temData[bindNameReg+i].nodes;
135 |     array.push(simArr);
136 |   }
137 | 
138 |   temArrayName = temArrayName || 'wxParseTemArray';
139 |   obj = JSON.parse('{"'+ temArrayName +'":""}');
140 |   obj[temArrayName] = array;
141 |   that.setData(obj);
142 | }
143 | 
144 | /**
145 |  * 配置emojis
146 |  * 
147 |  */
148 | 
149 | function emojisInit(reg='',baseSrc="/wxParse/emojis/",emojis){
150 |    HtmlToJson.emojisInit(reg,baseSrc,emojis);
151 | }
152 | 
153 | module.exports = {
154 |   wxParse: wxParse,
155 |   wxParseTemArray:wxParseTemArray,
156 |   emojisInit:emojisInit
157 | }
158 | 
159 | 
160 | 


--------------------------------------------------------------------------------
/pages/before-pay/before-pay.js:
--------------------------------------------------------------------------------
  1 | import BeforePayModel from './before-pay-model'
  2 | const beforePayModel = new BeforePayModel()
  3 | let g_timer = null
  4 | 
  5 | Page({
  6 |   data:{
  7 |     id: '',
  8 |     name: '',
  9 |     price: 0,
 10 |     num: 1,
 11 |     isBindPhone: false,
 12 |     isSendMsging: false,
 13 |     phone: '',
 14 |     code: '',
 15 |     nickname: '',
 16 |     timeOut: 60,
 17 |   },
 18 |   onLoad(options){
 19 |     const { name = '', price = 0, id='' } = options
 20 |     this.setData({
 21 |       id,
 22 |       name,
 23 |       price: Number(price),
 24 |     })
 25 |     
 26 |     this._checkIsBindPhone()
 27 |   },
 28 | 
 29 |   _checkIsBindPhone(token) {
 30 |     beforePayModel.checkIsBindPhone(res => {
 31 |       this.setData({
 32 |         isBindPhone: Boolean(Number(res.data.status))
 33 |       })
 34 |     })
 35 |   },
 36 | 
 37 |   subtractNum() {
 38 |     if(this.data.num > 1) {
 39 |       this.setData({
 40 |         num: this.data.num - 1
 41 |       })
 42 |     }
 43 |   },
 44 | 
 45 |   addNum() {
 46 |     this.setData({
 47 |       num: this.data.num + 1
 48 |     })
 49 |   },
 50 | 
 51 |   bindPhone(e) {
 52 |     this.setData({
 53 |       phone: e.detail.value.trim()
 54 |     })
 55 |   },
 56 | 
 57 |   bindCode(e) {
 58 |     this.setData({
 59 |       code: e.detail.value.trim()
 60 |     })
 61 |   },
 62 | 
 63 |   sendSmS() {
 64 |     if(!this.data.phone) {
 65 |       wx.showModal({
 66 |         title: '请输入手机号！',
 67 |         content: '',
 68 |         showCancel: false,
 69 |       })
 70 |       return 
 71 |     }
 72 |     
 73 |     if(this.data.phone.substring(0, 1) != 1 || this.data.phone.length !== 11) {
 74 |       wx.showModal({
 75 |         title: '手机号格式错误！',
 76 |         content: '',
 77 |         showCancel: false,
 78 |       })
 79 |       return 
 80 |     }
 81 | 
 82 |     this.setData({
 83 |       isSendMsging: true,
 84 |     })
 85 | 
 86 |     // 获取用户昵称
 87 |     const self = this    
 88 |     wx.getUserInfo({
 89 |       success(res) {
 90 |         self.setData({
 91 |           nickname:  res.userInfo.nickName,
 92 |         })
 93 |       }
 94 |     })
 95 | 
 96 |     // 60s 倒计时
 97 |     g_timer = setInterval(() => {
 98 |       if(this.data.timeOut === 1) {
 99 |         clearInterval(g_timer)
100 |         this.setData({
101 |           isSendMsging: false,
102 |           timeOut: 60,
103 |         })
104 |         return 
105 |       }
106 |       this.setData({
107 |         timeOut: this.data.timeOut - 1
108 |       })
109 |     }, 1000)
110 | 
111 |     this._serverSendSms()
112 |   },
113 | 
114 |   // 发送短信
115 |   _serverSendSms(token) {
116 |     const data = {
117 |       phone: this.data.phone,
118 |     }
119 |     beforePayModel.sendSmS(data, res => {
120 |       if(res.data.status != 1) {
121 |         wx.showModal({
122 |           title: '手机号发送失败，请退出重试！',
123 |           content: '',
124 |           showCancel: false,
125 |         })
126 |       }
127 |     })
128 |   },
129 | 
130 |   submitPay() {
131 |     if(this.data.isBindPhone) {
132 |       this._wxPay()
133 |       return
134 |     }
135 | 
136 |     if(!this.data.phone) {
137 |       wx.showModal({
138 |         title: '请输入手机号！',
139 |         content: '',
140 |         showCancel: false,
141 |       })
142 |       return 
143 |     }
144 | 
145 |     if(!this.data.code) {
146 |       wx.showModal({
147 |         title: '请输入验证码！',
148 |         content: '',
149 |         showCancel: false,
150 |       })
151 |       return 
152 |     }
153 |     this._postUserInfo()
154 |   },
155 | 
156 |   _postUserInfo() {
157 |     const data = {
158 |       nickname: this.data.nickname,
159 |       phone: this.data.phone,
160 |       code: this.data.code,
161 |     }
162 | 
163 |     beforePayModel.postUserInfo(data, res => {
164 |       if(res.data) {
165 |         if(res.data.status === 1) {
166 |           // 绑定手机号成功，继续微信支付
167 |           this.setData({
168 |             isBindPhone: true,
169 |           })
170 |           this._wxPay()
171 |         }  
172 |       } else if(res.errors){
173 |         // 验证码错误
174 |         wx.showModal({
175 |           title: '验证码错误！',
176 |           content: '',
177 |           showCancel: false,
178 |         })
179 | 
180 |         clearInterval(g_timer)
181 |         this.setData({
182 |           isSendMsging: false,
183 |           timeOut: 60,
184 |         })
185 |       }
186 |     })
187 |   },
188 | 
189 |   // 微信支付
190 |   _wxPay() {
191 |     const data = {
192 |       id: this.data.id,
193 |       num: this.data.num,
194 |     }
195 |     const self = this
196 |     beforePayModel.wxPay(data, res => {
197 |       if(res.data) {
198 |         const {
199 |           appid,
200 |           timestamp,
201 |           nonce_str,
202 |           pack_age,
203 |           sign_type,
204 |           pay_sign,
205 |           order_time
206 |         } = res.data
207 | 
208 |         wx.requestPayment({
209 |           timeStamp: timestamp,
210 |           nonceStr: nonce_str,
211 |           package: pack_age,
212 |           signType: 'MD5',
213 |           paySign: pay_sign,
214 |           success(res_pay){
215 |             console.log(`/pages/after-pay/after-pay?name=${self.data.name}&id=${self.data.id}&num=${self.data.num}&order_time=${order_time}&nonce_str=${nonce_str}`)
216 |             wx.redirectTo({
217 |               url: `/pages/after-pay/after-pay?name=${self.data.name}&id=${self.data.id}&num=${self.data.num}&order_time=${order_time}&nonce_str=${nonce_str}`
218 |             })
219 |           },
220 |           fail(){
221 |             wx.showModal({
222 |               title: '支付失败，请重试！',
223 |               content: '',
224 |               showCancel: false,
225 |             })
226 |           }
227 |         })
228 |       } else if(res.errors) {
229 |         wx.showModal({
230 |           title: '支付失败，请重试！',
231 |           content: '',
232 |           showCancel: false,
233 |         })
234 |       }
235 |     })
236 |   },
237 | 
238 |   onUnload(){
239 |     if(g_timer) clearInterval(g_timer)
240 |   }
241 | })
242 | 


--------------------------------------------------------------------------------
/pages/qr-pay/qr-pay.wxss:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * header ↓↓↓↓↓
  3 |  */
  4 | .header {
  5 |   padding-bottom: 30rpx;
  6 |   width: 100%;
  7 |   height: auto;
  8 |   background: #fff;
  9 |   font-size: 28rpx;
 10 | }
 11 | 
 12 | .media {
 13 |   margin-bottom: 36rpx;
 14 |   padding-top: 36rpx;
 15 |   width: 100%;
 16 |   height: auto;
 17 |   text-align: center;
 18 | }
 19 | 
 20 | .media image {
 21 |   width: 70rpx;
 22 |   height: 70rpx;
 23 |   display: inline-block;
 24 |   border: 1rpx solid #EBECF1;
 25 |   border-radius: 50%;
 26 | }
 27 | 
 28 | .media text {
 29 |   margin-top: 10rpx;
 30 |   display: block;
 31 |   color: #28354C;
 32 | }
 33 | 
 34 | .ipt_box {
 35 |   box-sizing: border-box;
 36 |   padding: 0 24rpx;
 37 |   width: 100%;
 38 |   height: 80rpx;
 39 | }
 40 | 
 41 | .ipt_box input {
 42 |   padding-left: 20rpx;
 43 |   box-sizing: border-box;
 44 |   width: 100%;
 45 |   height: inherit;
 46 |   background: #EBECF1;
 47 |   border-radius: 4px;
 48 | }
 49 | /*
 50 |  * header ↑↑↑↑
 51 |  */
 52 | 
 53 | .coupon_list {
 54 |   padding: 30rpx 24rpx;
 55 |   box-sizing: border-box;
 56 |   width: 100%;
 57 |   font-size: 28rpx;
 58 | }
 59 | 
 60 | .coupon_num {
 61 |   font-size: 28rpx;
 62 |   color: #A6A8B6;
 63 | }
 64 | 
 65 | .coupon {
 66 |   margin-top: 20rpx;
 67 |   padding: 0 24rpx;
 68 |   box-sizing: border-box;
 69 |   width: 100%;
 70 |   height: 100rpx;
 71 |   line-height: 100rpx;
 72 |   background: #fff;
 73 |   color: #28354C;
 74 | }
 75 | 
 76 | .coupon image {
 77 |   margin-right: 20rpx;
 78 |   width: 60rpx;
 79 |   height: 60rpx;
 80 |   vertical-align: middle;
 81 |   border: 1rpx solid #EBECF1;
 82 |   border-radius: 50%;
 83 | }
 84 | 
 85 | .coupon_name {
 86 |   margin-right: 20rpx;
 87 | }
 88 | 
 89 | .weui-check__label {
 90 |   /*margin-top: 10rpx;*/
 91 |   float: right;
 92 | }
 93 | 
 94 | .weui-check__hd_in-checkbox {
 95 |   margin-top: 14rpx;
 96 |   height: 50rpx;
 97 | }
 98 | 
 99 | .cell_box {
100 |   display: flex;
101 |   padding: 0 24rpx;
102 |   font-size: 28rpx;
103 |   width: 100%;
104 |   height: 100rpx;
105 |   box-sizing: border-box;
106 |   background: #fff;
107 |   line-height: 100rpx;
108 |   border-bottom: 1px #ebecf1 solid; 
109 |   overflow: hidden;
110 | }
111 | 
112 | .cell_bd {
113 |   flex: 3;
114 |   height: inherit;
115 |   color: #28354C;
116 | }
117 | 
118 | .cell_ft {
119 |   height: inherit;  
120 |   color: #E3007E;
121 |   text-align: right;
122 |   flex: 2;
123 |   display: flex;
124 |   align-items: center;
125 |   justify-content: flex-end;
126 | }
127 | 
128 | .button {
129 |   margin-top: 100rpx;
130 |   margin-bottom: 40rpx;
131 | }
132 | 
133 | 
134 | 
135 | /*!
136 |  * WeUI v1.1.1 (https://github.com/weui/weui-wxss)
137 |  * Copyright 2017 Tencent, Inc.
138 |  * Licensed under the MIT license
139 |  */
140 | .weui-icon-radio{margin-left:3.2px;margin-right:3.2px}.weui-icon-checkbox_circle,.weui-icon-checkbox_success{margin-left:4.6px;margin-right:4.6px}.weui-check__label:active{background-color:#ececec}.weui-check{position:absolute;left:-9999px}.weui-check__hd_in-checkbox{padding-right:.35em}.weui-cell__ft_in-radio{padding-left:.35em}
141 | /*!
142 |  * WeUI v1.1.1 (https://github.com/weui/weui-wxss)
143 |  * Copyright 2017 Tencent, Inc.
144 |  * Licensed under the MIT license
145 |  */
146 | .weui-cell_input{padding-top:0;padding-bottom:0}.weui-label{width:105px;word-wrap:break-word;word-break:break-all}.weui-input{height:2.58823529em;min-height:2.58823529em;line-height:2.58823529em}.weui-toptips{position:fixed;-webkit-transform:translateZ(0);transform:translateZ(0);top:0;left:0;right:0;padding:5px;font-size:14px;text-align:center;color:#fff;z-index:5000;word-wrap:break-word;word-break:break-all}.weui-toptips_warn{background-color:#e64340}.weui-textarea{display:block;width:100%}.weui-textarea-counter{color:#b2b2b2;text-align:right}.weui-cell_warn,.weui-textarea-counter_warn{color:#e64340}.weui-form-preview{position:relative;background-color:#fff}.weui-form-preview:before{top:0;border-top:1rpx solid #d9d9d9}.weui-form-preview:after,.weui-form-preview:before{content:" ";position:absolute;left:0;right:0;height:1px;color:#d9d9d9}.weui-form-preview:after{bottom:0;border-bottom:1rpx solid #d9d9d9}.weui-form-preview__value{font-size:14px}.weui-form-preview__value_in-hd{font-size:26px}.weui-form-preview__hd{position:relative;padding:10px 15px;text-align:right;line-height:2.5em}.weui-form-preview__hd:after{content:" ";position:absolute;left:0;bottom:0;right:0;height:1px;border-bottom:1rpx solid #d9d9d9;color:#d9d9d9;left:15px}.weui-form-preview__bd{padding:10px 15px;font-size:.9em;text-align:right;color:#999;line-height:2}.weui-form-preview__ft{position:relative;line-height:50px;display:-webkit-box;display:-webkit-flex;display:flex}.weui-form-preview__ft:after{content:" ";position:absolute;left:0;top:0;right:0;height:1px;border-top:1rpx solid #d5d5d6;color:#d5d5d6}.weui-form-preview__item{overflow:hidden}.weui-form-preview__label{float:left;margin-right:1em;min-width:4em;color:#999;text-align:justify;text-align-last:justify}.weui-form-preview__value{display:block;overflow:hidden;word-break:normal;word-wrap:break-word}.weui-form-preview__btn{position:relative;display:block;-webkit-box-flex:1;-webkit-flex:1;flex:1;color:#3cc51f;text-align:center}.weui-form-preview__btn:after{content:" ";position:absolute;left:0;top:0;width:1px;bottom:0;border-left:1rpx solid #d5d5d6;color:#d5d5d6}.weui-form-preview__btn:first-child:after{display:none}.weui-form-preview__btn_active{background-color:#eee}.weui-form-preview__btn_default{color:#999}.weui-form-preview__btn_primary{color:#0bb20c}.weui-cell_select{padding:0}.weui-select{position:relative;padding-left:15px;padding-right:30px;height:2.58823529em;min-height:2.58823529em;line-height:2.58823529em;border-right:1rpx solid #d9d9d9}.weui-select:before{content:" ";display:inline-block;height:6px;width:6px;border-width:2px 2px 0 0;border-color:#c8c8cd;border-style:solid;-webkit-transform:matrix(.71,.71,-.71,.71,0,0);transform:matrix(.71,.71,-.71,.71,0,0);position:relative;top:-2px;position:absolute;top:50%;right:15px;margin-top:-4px}.weui-select_in-select-after{padding-left:0}.weui-cell__bd_in-select-before,.weui-cell__hd_in-select-after{padding-left:15px}.weui-cell_vcode{padding-right:0}.weui-vcode-btn,.weui-vcode-img{margin-left:5px;height:2.58823529em;vertical-align:middle}.weui-vcode-btn{display:inline-block;padding:0 .6em 0 .7em;border-left:1px solid #e5e5e5;line-height:2.58823529em;font-size:17px;color:#3cc51f;white-space:nowrap}.weui-vcode-btn:active{color:#52a341}


--------------------------------------------------------------------------------
/common/wxParse/htmlparser.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 
  3 |  * htmlParser改造自: https://github.com/blowsie/Pure-JavaScript-HTML5-Parser
  4 |  * 
  5 |  * author: Di (微信小程序开发工程师)
  6 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  7 |  *               垂直微信小程序开发交流社区
  8 |  * 
  9 |  * github地址: https://github.com/icindy/wxParse
 10 |  * 
 11 |  * for: 微信小程序富文本解析
 12 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 13 |  */
 14 | // Regular Expressions for parsing tags and attributes
 15 | var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
 16 | 	endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/,
 17 | 	attr = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
 18 | 
 19 | // Empty Elements - HTML 5
 20 | var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr");
 21 | 
 22 | // Block Elements - HTML 5
 23 | var block = makeMap("a,address,code,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");
 24 | 
 25 | // Inline Elements - HTML 5
 26 | var inline = makeMap("abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,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");
 27 | 
 28 | // Elements that you can, intentionally, leave open
 29 | // (and which close themselves)
 30 | var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
 31 | 
 32 | // Attributes that have their values filled in disabled="disabled"
 33 | var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
 34 | 
 35 | // Special Elements (can contain anything)
 36 | var special = makeMap("wxxxcode-style,script,style,view,scroll-view,block");
 37 | 
 38 | function HTMLParser(html, handler) {
 39 | 	var index, chars, match, stack = [], last = html;
 40 | 	stack.last = function () {
 41 | 		return this[this.length - 1];
 42 | 	};
 43 | 
 44 | 	while (html) {
 45 | 		chars = true;
 46 | 
 47 | 		// Make sure we're not in a script or style element
 48 | 		if (!stack.last() || !special[stack.last()]) {
 49 | 
 50 | 			// Comment
 51 | 			if (html.indexOf("<!--") == 0) {
 52 | 				index = html.indexOf("-->");
 53 | 
 54 | 				if (index >= 0) {
 55 | 					if (handler.comment)
 56 | 						handler.comment(html.substring(4, index));
 57 | 					html = html.substring(index + 3);
 58 | 					chars = false;
 59 | 				}
 60 | 
 61 | 				// end tag
 62 | 			} else if (html.indexOf("</") == 0) {
 63 | 				match = html.match(endTag);
 64 | 
 65 | 				if (match) {
 66 | 					html = html.substring(match[0].length);
 67 | 					match[0].replace(endTag, parseEndTag);
 68 | 					chars = false;
 69 | 				}
 70 | 
 71 | 				// start tag
 72 | 			} else if (html.indexOf("<") == 0) {
 73 | 				match = html.match(startTag);
 74 | 
 75 | 				if (match) {
 76 | 					html = html.substring(match[0].length);
 77 | 					match[0].replace(startTag, parseStartTag);
 78 | 					chars = false;
 79 | 				}
 80 | 			}
 81 | 
 82 | 			if (chars) {
 83 | 				index = html.indexOf("<");
 84 | 				var text = ''
 85 | 				while (index === 0) {
 86 |                                   text += "<";
 87 |                                   html = html.substring(1);
 88 |                                   index = html.indexOf("<");
 89 | 				}
 90 | 				text += index < 0 ? html : html.substring(0, index);
 91 | 				html = index < 0 ? "" : html.substring(index);
 92 | 
 93 | 				if (handler.chars)
 94 | 					handler.chars(text);
 95 | 			}
 96 | 
 97 | 		} else {
 98 | 
 99 | 			html = html.replace(new RegExp("([\\s\\S]*?)<\/" + stack.last() + "[^>]*>"), function (all, text) {
100 | 				text = text.replace(/<!--([\s\S]*?)-->|<!\[CDATA\[([\s\S]*?)]]>/g, "$1$2");
101 | 				if (handler.chars)
102 | 					handler.chars(text);
103 | 
104 | 				return "";
105 | 			});
106 | 
107 | 
108 | 			parseEndTag("", stack.last());
109 | 		}
110 | 
111 | 		if (html == last)
112 | 			throw "Parse Error: " + html;
113 | 		last = html;
114 | 	}
115 | 
116 | 	// Clean up any remaining tags
117 | 	parseEndTag();
118 | 
119 | 	function parseStartTag(tag, tagName, rest, unary) {
120 | 		tagName = tagName.toLowerCase();
121 | 
122 | 		if (block[tagName]) {
123 | 			while (stack.last() && inline[stack.last()]) {
124 | 				parseEndTag("", stack.last());
125 | 			}
126 | 		}
127 | 
128 | 		if (closeSelf[tagName] && stack.last() == tagName) {
129 | 			parseEndTag("", tagName);
130 | 		}
131 | 
132 | 		unary = empty[tagName] || !!unary;
133 | 
134 | 		if (!unary)
135 | 			stack.push(tagName);
136 | 
137 | 		if (handler.start) {
138 | 			var attrs = [];
139 | 
140 | 			rest.replace(attr, function (match, name) {
141 | 				var value = arguments[2] ? arguments[2] :
142 | 					arguments[3] ? arguments[3] :
143 | 						arguments[4] ? arguments[4] :
144 | 							fillAttrs[name] ? name : "";
145 | 
146 | 				attrs.push({
147 | 					name: name,
148 | 					value: value,
149 | 					escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
150 | 				});
151 | 			});
152 | 
153 | 			if (handler.start) {
154 | 				handler.start(tagName, attrs, unary);
155 | 			}
156 | 
157 | 		}
158 | 	}
159 | 
160 | 	function parseEndTag(tag, tagName) {
161 | 		// If no tag name is provided, clean shop
162 | 		if (!tagName)
163 | 			var pos = 0;
164 | 
165 | 		// Find the closest opened tag of the same type
166 | 		else {
167 | 			tagName = tagName.toLowerCase();
168 | 			for (var pos = stack.length - 1; pos >= 0; pos--)
169 | 				if (stack[pos] == tagName)
170 | 					break;
171 | 		}
172 | 		if (pos >= 0) {
173 | 			// Close all the open elements, up the stack
174 | 			for (var i = stack.length - 1; i >= pos; i--)
175 | 				if (handler.end)
176 | 					handler.end(stack[i]);
177 | 
178 | 			// Remove the open elements from the stack
179 | 			stack.length = pos;
180 | 		}
181 | 	}
182 | };
183 | 
184 | 
185 | function makeMap(str) {
186 | 	var obj = {}, items = str.split(",");
187 | 	for (var i = 0; i < items.length; i++)
188 | 		obj[items[i]] = true;
189 | 	return obj;
190 | }
191 | 
192 | module.exports = HTMLParser;
193 | 


--------------------------------------------------------------------------------
/common/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 |     str = str.replace(/&middot;/g, '·');
 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 |     str = str.replace(/&lt;/g, '<');
113 |     str = str.replace(/&gt;/g, '>');
114 | 
115 |     return str;
116 | }
117 | 
118 | // HTML 支持的其他实体
119 | function strOtherDiscode(str){
120 |     str = str.replace(/&OElig;/g, 'Œ');
121 |     str = str.replace(/&oelig;/g, 'œ');
122 |     str = str.replace(/&Scaron;/g, 'Š');
123 |     str = str.replace(/&scaron;/g, 'š');
124 |     str = str.replace(/&Yuml;/g, 'Ÿ');
125 |     str = str.replace(/&fnof;/g, 'ƒ');
126 |     str = str.replace(/&circ;/g, 'ˆ');
127 |     str = str.replace(/&tilde;/g, '˜');
128 |     str = str.replace(/&ensp;/g, '');
129 |     str = str.replace(/&emsp;/g, '');
130 |     str = str.replace(/&thinsp;/g, '');
131 |     str = str.replace(/&zwnj;/g, '');
132 |     str = str.replace(/&zwj;/g, '');
133 |     str = str.replace(/&lrm;/g, '');
134 |     str = str.replace(/&rlm;/g, '');
135 |     str = str.replace(/&ndash;/g, '–');
136 |     str = str.replace(/&mdash;/g, '—');
137 |     str = str.replace(/&lsquo;/g, '‘');
138 |     str = str.replace(/&rsquo;/g, '’');
139 |     str = str.replace(/&sbquo;/g, '‚');
140 |     str = str.replace(/&ldquo;/g, '“');
141 |     str = str.replace(/&rdquo;/g, '”');
142 |     str = str.replace(/&bdquo;/g, '„');
143 |     str = str.replace(/&dagger;/g, '†');
144 |     str = str.replace(/&Dagger;/g, '‡');
145 |     str = str.replace(/&bull;/g, '•');
146 |     str = str.replace(/&hellip;/g, '…');
147 |     str = str.replace(/&permil;/g, '‰');
148 |     str = str.replace(/&prime;/g, '′');
149 |     str = str.replace(/&Prime;/g, '″');
150 |     str = str.replace(/&lsaquo;/g, '‹');
151 |     str = str.replace(/&rsaquo;/g, '›');
152 |     str = str.replace(/&oline;/g, '‾');
153 |     str = str.replace(/&euro;/g, '€');
154 |     str = str.replace(/&trade;/g, '™');
155 | 
156 |     str = str.replace(/&larr;/g, '←');
157 |     str = str.replace(/&uarr;/g, '↑');
158 |     str = str.replace(/&rarr;/g, '→');
159 |     str = str.replace(/&darr;/g, '↓');
160 |     str = str.replace(/&harr;/g, '↔');
161 |     str = str.replace(/&crarr;/g, '↵');
162 |     str = str.replace(/&lceil;/g, '⌈');
163 |     str = str.replace(/&rceil;/g, '⌉');
164 | 
165 |     str = str.replace(/&lfloor;/g, '⌊');
166 |     str = str.replace(/&rfloor;/g, '⌋');
167 |     str = str.replace(/&loz;/g, '◊');
168 |     str = str.replace(/&spades;/g, '♠');
169 |     str = str.replace(/&clubs;/g, '♣');
170 |     str = str.replace(/&hearts;/g, '♥');
171 | 
172 |     str = str.replace(/&diams;/g, '♦');
173 |     str = str.replace(/&#39;/g, '\'');
174 |     return str;
175 | }
176 | 
177 | function strMoreDiscode(str){
178 |     str = str.replace(/\r\n/g,"");  
179 |     str = str.replace(/\n/g,"");
180 | 
181 |     str = str.replace(/code/g,"wxxxcode-style");
182 |     return str;
183 | }
184 | 
185 | function strDiscode(str){
186 |     str = strNumDiscode(str);
187 |     str = strGreeceDiscode(str);
188 |     str = strcharacterDiscode(str);
189 |     str = strOtherDiscode(str);
190 |     str = strMoreDiscode(str);
191 |     return str;
192 | }
193 | function urlToHttpUrl(url,rep){
194 |     
195 |     var patt1 = new RegExp("^//");
196 |     var result = patt1.test(url);
197 |     if(result){
198 |         url = rep+":"+url;
199 |     }
200 |     return  url;
201 | }
202 | 
203 | module.exports = {
204 |     strDiscode:strDiscode,
205 |     urlToHttpUrl:urlToHttpUrl
206 | }


--------------------------------------------------------------------------------
/common/wxParse/html2json.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * html2Json 改造来自: https://github.com/Jxck/html2json
  3 |  * 
  4 |  * 
  5 |  * author: Di (微信小程序开发工程师)
  6 |  * organization: WeAppDev(微信小程序开发论坛)(http://weappdev.com)
  7 |  *               垂直微信小程序开发交流社区
  8 |  * 
  9 |  * github地址: https://github.com/icindy/wxParse
 10 |  * 
 11 |  * for: 微信小程序富文本解析
 12 |  * detail : http://weappdev.com/t/wxparse-alpha0-1-html-markdown/184
 13 |  */
 14 | 
 15 | var __placeImgeUrlHttps = "https";
 16 | var __emojisReg = '';
 17 | var __emojisBaseSrc = '';
 18 | var __emojis = {};
 19 | var wxDiscode = require('./wxDiscode.js');
 20 | var HTMLParser = require('./htmlparser.js');
 21 | // Empty Elements - HTML 5
 22 | var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr");
 23 | // Block Elements - HTML 5
 24 | var block = makeMap("br,a,code,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");
 25 | 
 26 | // Inline Elements - HTML 5
 27 | var inline = makeMap("abbr,acronym,applet,b,basefont,bdo,big,button,cite,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");
 28 | 
 29 | // Elements that you can, intentionally, leave open
 30 | // (and which close themselves)
 31 | var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
 32 | 
 33 | // Attributes that have their values filled in disabled="disabled"
 34 | var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
 35 | 
 36 | // Special Elements (can contain anything)
 37 | var special = makeMap("wxxxcode-style,script,style,view,scroll-view,block");
 38 | function makeMap(str) {
 39 |     var obj = {}, items = str.split(",");
 40 |     for (var i = 0; i < items.length; i++)
 41 |         obj[items[i]] = true;
 42 |     return obj;
 43 | }
 44 | 
 45 | function q(v) {
 46 |     return '"' + v + '"';
 47 | }
 48 | 
 49 | function removeDOCTYPE(html) {
 50 |     return html
 51 |         .replace(/<\?xml.*\?>\n/, '')
 52 |         .replace(/<.*!doctype.*\>\n/, '')
 53 |         .replace(/<.*!DOCTYPE.*\>\n/, '');
 54 | }
 55 | 
 56 | 
 57 | function html2json(html, bindName) {
 58 |     //处理字符串
 59 |     html = removeDOCTYPE(html);
 60 |     html = wxDiscode.strDiscode(html);
 61 |     //生成node节点
 62 |     var bufArray = [];
 63 |     var results = {
 64 |         node: bindName,
 65 |         nodes: [],
 66 |         images:[],
 67 |         imageUrls:[]
 68 |     };
 69 |     var index = 0;
 70 |     HTMLParser(html, {
 71 |         start: function (tag, attrs, unary) {
 72 |             //debug(tag, attrs, unary);
 73 |             // node for this element
 74 |             var node = {
 75 |                 node: 'element',
 76 |                 tag: tag,
 77 |             };
 78 | 
 79 |             if (bufArray.length === 0) {
 80 |                 node.index = index.toString()
 81 |                 index += 1
 82 |             } else {
 83 |                 var parent = bufArray[0];
 84 |                 if (parent.nodes === undefined) {
 85 |                     parent.nodes = [];
 86 |                 }
 87 |                 node.index = parent.index + '.' + parent.nodes.length
 88 |             }
 89 | 
 90 |             if (block[tag]) {
 91 |                 node.tagType = "block";
 92 |             } else if (inline[tag]) {
 93 |                 node.tagType = "inline";
 94 |             } else if (closeSelf[tag]) {
 95 |                 node.tagType = "closeSelf";
 96 |             }
 97 | 
 98 |             if (attrs.length !== 0) {
 99 |                 node.attr = attrs.reduce(function (pre, attr) {
100 |                     var name = attr.name;
101 |                     var value = attr.value;
102 |                     if (name == 'class') {
103 |                         console.dir(value);
104 |                         //  value = value.join("")
105 |                         node.classStr = value;
106 |                     }
107 |                     // has multi attibutes
108 |                     // make it array of attribute
109 |                     if (name == 'style') {
110 |                         console.dir(value);
111 |                         //  value = value.join("")
112 |                         node.styleStr = value;
113 |                     }
114 |                     if (value.match(/ /)) {
115 |                         value = value.split(' ');
116 |                     }
117 |                     
118 | 
119 |                     // if attr already exists
120 |                     // merge it
121 |                     if (pre[name]) {
122 |                         if (Array.isArray(pre[name])) {
123 |                             // already array, push to last
124 |                             pre[name].push(value);
125 |                         } else {
126 |                             // single value, make it array
127 |                             pre[name] = [pre[name], value];
128 |                         }
129 |                     } else {
130 |                         // not exist, put it
131 |                         pre[name] = value;
132 |                     }
133 | 
134 |                     return pre;
135 |                 }, {});
136 |             }
137 | 
138 |             //对img添加额外数据
139 |             if (node.tag === 'img') {
140 |                 node.imgIndex = results.images.length;
141 |                 var imgUrl = node.attr.src;
142 |                 if (imgUrl[0] == '') {
143 |                     imgUrl.splice(0, 1);
144 |                 }
145 |                 imgUrl = wxDiscode.urlToHttpUrl(imgUrl, __placeImgeUrlHttps);
146 |                 node.attr.src = imgUrl;
147 |                 node.from = bindName;
148 |                 results.images.push(node);
149 |                 results.imageUrls.push(imgUrl);
150 |             }
151 |             
152 |             // 处理font标签样式属性
153 |             if (node.tag === 'font') {
154 |                 var fontSize = ['x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', '-webkit-xxx-large'];
155 |                 var styleAttrs = {
156 |                     'color': 'color',
157 |                     'face': 'font-family',
158 |                     'size': 'font-size'
159 |                 };
160 |                 if (!node.attr.style) node.attr.style = [];
161 |                 if (!node.styleStr) node.styleStr = '';
162 |                 for (var key in styleAttrs) {
163 |                     if (node.attr[key]) {
164 |                         var value = key === 'size' ? fontSize[node.attr[key]-1] : node.attr[key];
165 |                         node.attr.style.push(styleAttrs[key]);
166 |                         node.attr.style.push(value);
167 |                         node.styleStr += styleAttrs[key] + ': ' + value + ';';
168 |                     }
169 |                 }
170 |             }
171 | 
172 |             //临时记录source资源
173 |             if(node.tag === 'source'){
174 |                 results.source = node.attr.src;
175 |             }
176 |             
177 |             if (unary) {
178 |                 // if this tag dosen't have end tag
179 |                 // like <img src="hoge.png"/>
180 |                 // add to parents
181 |                 var parent = bufArray[0] || results;
182 |                 if (parent.nodes === undefined) {
183 |                     parent.nodes = [];
184 |                 }
185 |                 parent.nodes.push(node);
186 |             } else {
187 |                 bufArray.unshift(node);
188 |             }
189 |         },
190 |         end: function (tag) {
191 |             //debug(tag);
192 |             // merge into parent tag
193 |             var node = bufArray.shift();
194 |             if (node.tag !== tag) console.error('invalid state: mismatch end tag');
195 | 
196 |             //当有缓存source资源时于于video补上src资源
197 |             if(node.tag === 'video' && results.source){
198 |                 node.attr.src = results.source;
199 |                 delete result.source;
200 |             }
201 |             
202 |             if (bufArray.length === 0) {
203 |                 results.nodes.push(node);
204 |             } else {
205 |                 var parent = bufArray[0];
206 |                 if (parent.nodes === undefined) {
207 |                     parent.nodes = [];
208 |                 }
209 |                 parent.nodes.push(node);
210 |             }
211 |         },
212 |         chars: function (text) {
213 |             //debug(text);
214 |             var node = {
215 |                 node: 'text',
216 |                 text: text,
217 |                 textArray:transEmojiStr(text)
218 |             };
219 |             
220 |             if (bufArray.length === 0) {
221 |                 results.nodes.push(node);
222 |             } else {
223 |                 var parent = bufArray[0];
224 |                 if (parent.nodes === undefined) {
225 |                     parent.nodes = [];
226 |                 }
227 |                 node.index = parent.index + '.' + parent.nodes.length
228 |                 parent.nodes.push(node);
229 |             }
230 |         },
231 |         comment: function (text) {
232 |             //debug(text);
233 |             // var node = {
234 |             //     node: 'comment',
235 |             //     text: text,
236 |             // };
237 |             // var parent = bufArray[0];
238 |             // if (parent.nodes === undefined) {
239 |             //     parent.nodes = [];
240 |             // }
241 |             // parent.nodes.push(node);
242 |         },
243 |     });
244 |     return results;
245 | };
246 | 
247 | function transEmojiStr(str){
248 |   // var eReg = new RegExp("["+__reg+' '+"]");
249 | //   str = str.replace(/\[([^\[\]]+)\]/g,':$1:')
250 |   
251 |   var emojiObjs = [];
252 |   //如果正则表达式为空
253 |   if(__emojisReg.length == 0 || !__emojis){
254 |       var emojiObj = {}
255 |       emojiObj.node = "text";
256 |       emojiObj.text = str;
257 |       array = [emojiObj];
258 |       return array;
259 |   }
260 |   //这个地方需要调整
261 |   str = str.replace(/\[([^\[\]]+)\]/g,':$1:')
262 |   var eReg = new RegExp("[:]");
263 |   var array = str.split(eReg);
264 |   for(var i = 0; i < array.length; i++){
265 |     var ele = array[i];
266 |     var emojiObj = {};
267 |     if(__emojis[ele]){
268 |       emojiObj.node = "element";
269 |       emojiObj.tag = "emoji";
270 |       emojiObj.text = __emojis[ele];
271 |       emojiObj.baseSrc= __emojisBaseSrc;
272 |     }else{
273 |       emojiObj.node = "text";
274 |       emojiObj.text = ele;
275 |     }
276 |     emojiObjs.push(emojiObj);
277 |   }
278 |   
279 |   return emojiObjs;
280 | }
281 | 
282 | function emojisInit(reg='',baseSrc="/wxParse/emojis/",emojis){
283 |     __emojisReg = reg;
284 |     __emojisBaseSrc=baseSrc;
285 |     __emojis=emojis;
286 | }
287 | 
288 | module.exports = {
289 |     html2json: html2json,
290 |     emojisInit:emojisInit
291 | };
292 | 
293 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


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


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


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