├── blog.php
├── blog.webp
├── load_blog.php
├── README.md
├── styles.css
├── stylespc.css
├── blog.txt
├── write.php
├── LICENSE
└── Parsedown.php


/blog.php:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blog.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noner-cmd/An-efficient-blog/HEAD/blog.webp


--------------------------------------------------------------------------------
/load_blog.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // 读取 blog.txt 文件内容
 3 | $file = 'blog.txt';
 4 | 
 5 | // 检查文件是否存在
 6 | if (file_exists($file)) {
 7 |     // 获取文件内容
 8 |     $blogs = file_get_contents($file);
 9 | 
10 |     // 返回内容给前端
11 |     echo nl2br($blogs);  // nl2br 用于在换行符处插入 <br> 标签
12 | } else {
13 |     echo "没有找到博客内容";
14 | }
15 | ?>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 此项目新版本更新将在https://github.com/noner-cmd/Triangle-blog/
 2 | 进行
 3 | 
 4 | 
 5 | # Read Me
 6 | 
 7 | ## 项目概述
 8 | 
 9 | 本项目是一个无需数据库支持的博客系统，旨在通过减少对数据库的依赖来提升页面加载速度并节省服务器性能。
10 | 
11 | ## 功能特点
12 | 
13 | - **无需数据库**：博客内容直接存储在`blog.txt`文件中，无需数据库支持。
14 | - **内容管理**：通过`write.php`页面，博主可以发布新的博客内容和管理已有博客（包括发布和删除）。
15 | - **密码验证**：发布和删除博客内容时需要密码验证，初始密码为`root`，可在`write.php`文件的第三行`$correctPassword = 'root';`处自行修改。
16 | - **内容存储**：博客内容（包括标题、发布时间和内容）存储在`blog.txt`中。
17 | - **页面展示**：用户访问`blog.php`时，该页面会调用`load_blog.php`来获取`blog.txt`中的内容，并按照格式显示在页面中。
18 | - **响应式设计**：通过媒体查询判断设备类型，并使用不同的CSS适配手机和电脑。
19 | 
20 | ## 部署指南
21 | 
22 | 1. **下载源文件**：直接下载本项目的所有源文件。
23 | 2. **上传至服务器**：将下载的源文件上传至您的服务器。
24 | 3. **配置密码**：在`write.php`文件中，将`$correctPassword`的值替换为您希望设置的密码。
25 | 4. **访问博客**：通过浏览器访问`blog.php`来查看博客内容。
26 | 
27 | 
28 | ## 文件结构
29 | 
30 | - `blog.php`：博客首页，用于展示博客内容。
31 | - `load_blog.php`：用于从`blog.txt`加载博客内容的脚本。
32 | - `write.php`：博主用于发布和管理博客内容的页面。
33 | - `blog.txt`：存储博客内容的文本文件。
34 | 
35 | ## 注意事项
36 | 
37 | - 请确保服务器支持PHP语言环境。
38 | - 在部署前，检查所有文件的权限设置，确保服务器可以正确读取和写入文件。
39 | - 定期备份`blog.txt`文件，以防数据丢失。
40 | 


--------------------------------------------------------------------------------
/styles.css:
--------------------------------------------------------------------------------
  1 |         body {
  2 |             margin: 0;
  3 |             font-family: Arial, sans-serif;
  4 |             background-color: #DFE5F0;
  5 |             color: #394E6A;
  6 |             padding-top: 60px; /* 增加这个样式，使页面整体下移60px */
  7 |             font-weight: bold;
  8 |         }
  9 | 
 10 |         /* 顶部导航栏 */
 11 |         header {
 12 |             width: 100%;
 13 |             height: 60px;
 14 |             background-color: #fff;
 15 |             position: fixed;
 16 |             top: 0;
 17 |             left: 0;
 18 |             z-index: 1000;
 19 |             display: flex;
 20 |             justify-content: space-between;
 21 |             align-items: center;
 22 |             padding: 0 px;
 23 |         }
 24 | 
 25 |         
 26 | 
 27 |         
 28 | 
 29 | 
 30 | 
 31 |         header h1 {
 32 |             font-weight: bold;
 33 |             font-size: 20px;
 34 |             margin: 0;
 35 |             text-align: center;
 36 |             flex-grow: 1;
 37 |         }
 38 | 
 39 | 
 40 |         /* 容器样式 */
 41 |         .container {
 42 |             margin: 15px;
 43 |             padding: 20px;
 44 |             background-color: #fff;
 45 |             border-radius: 20px;
 46 |             box-sizing: border-box;
 47 |             margin-top: 15px; /* 为了给导航栏留空间 */
 48 |         }
 49 | 
 50 |         .container img {
 51 |             width: 100%;
 52 |             border-radius: 10px;
 53 |             margin: 0;
 54 |         }
 55 | 
 56 |         .title {
 57 |             text-align: center;
 58 |             font-size: 36px;
 59 |             font-weight: bold;
 60 |             margin: 20px 0;
 61 |         }
 62 | 
 63 |         .content {
 64 |             font-size: 18px;
 65 |             line-height: 1.6;
 66 |         }
 67 | 
 68 |         .icons {
 69 |             display: flex;
 70 |             justify-content: space-around;
 71 |             margin-top: 20px;
 72 |         }
 73 | 
 74 |         .icons a {
 75 |             font-size: 30px;
 76 |             color: #394E6A;
 77 |             text-decoration: none;
 78 |         }
 79 | 
 80 | /* 页尾容器 */
 81 | .footer-content {
 82 |     font-size: 20px; /* 调大字体大小 */
 83 |     text-align: center; /* 居中对齐 */
 84 | }
 85 |         /* 样式调整 */
 86 |         .btn {
 87 |             margin-top: 20px;
 88 |             display: block;
 89 |             padding: 10px;
 90 |             text-align: center;
 91 |             background-color: #394E6A;
 92 |             color: white;
 93 |             font-weight: bold;
 94 |             text-decoration: none;
 95 |             border-radius: 10px;
 96 |         }
 97 | 
 98 |         .btn:hover {
 99 |             background-color: #2e3a51;
100 |         }


--------------------------------------------------------------------------------
/stylespc.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |   margin: 0;
  3 |   font-family: Arial, sans-serif;
  4 |   background-color: #DFE5F0;
  5 |   color: #394E6A;
  6 |   padding-top: 60px; /* 页面整体下移60px */
  7 |   font-weight: bold;
  8 | }
  9 | 
 10 | /* 顶部导航栏 */
 11 | header {
 12 |   width: 100%;
 13 |   height: 60px;
 14 |   background-color: #fff;
 15 |   position: fixed;
 16 |   top: 0;
 17 |   left: 0;
 18 |   z-index: 1000;
 19 |   display: flex;
 20 |   justify-content: space-between;
 21 |   align-items: center;
 22 |   padding: 0px;
 23 | }
 24 | 
 25 | 
 26 | 
 27 | header h1 {
 28 |   font-weight: bold;
 29 |   font-size: 20px;
 30 |   margin: 0;
 31 |   text-align: center;
 32 |   flex-grow: 1;
 33 | }
 34 | 
 35 | 
 36 |         header h1 {
 37 |             font-weight: bold;
 38 |             font-size: 20px;
 39 |             margin: 0;
 40 |             text-align: center;
 41 |             flex-grow: 1;
 42 |         }
 43 | 
 44 | 
 45 | 
 46 | /* 布局样式 */
 47 | .layout {
 48 |   display: flex;
 49 |   padding: 20px;
 50 |   width: 100%;
 51 |   overflow-x: hidden;  /*禁止横向滚动 */ 
 52 | }
 53 | 
 54 | /* 左侧固定 */
 55 | .left {
 56 |   position: fixed; /* 固定在页面左侧 */
 57 |   top: 60px; /* 导航栏下方 */
 58 |   left: 0;
 59 |   width: calc(33% + 10px); /* 左侧固定宽度 */
 60 |   height: calc(100% - 60px); /* 高度为剩余空间 */
 61 |   background-color: #DFE5F0;; /* 可以自定义左侧的背景色 */
 62 |   overflow-y: auto; /* 如果内容超出时可以垂直滚动 */
 63 | }
 64 | 
 65 | /* 右侧内容区域 */
 66 | .right {
 67 |   position: fixed; /* 固定在页面左侧 */
 68 |   top: 60px; /* 导航栏下方 */
 69 |   margin-left: calc(33% - 20px); /* 右侧留出左侧宽度 */
 70 |   width: 66%; /* 左侧固定宽度 */
 71 |   height: calc(100% - 60px); /* 高度为剩余空间 */
 72 |   background-color: #DFE5F0;; /* 可以自定义左侧的背景色 */
 73 |   overflow-y: auto; /* 如果内容超出时可以垂直滚动 */
 74 | }
 75 | 
 76 | /* 容器样式 */
 77 | .container {
 78 |   margin: 15px;
 79 |   padding: 20px;
 80 |   background-color: #fff;
 81 |   border-radius: 20px;
 82 |   box-sizing: border-box;
 83 |   margin-top: 15px; /* 为了给导航栏留空间 */
 84 | }
 85 | 
 86 | .container img {
 87 |   width: 100%;
 88 |   border-radius: 10px;
 89 |   margin: 0;
 90 | }
 91 | 
 92 | .title {
 93 |   text-align: center;
 94 |   font-size: 36px;
 95 |   font-weight: bold;
 96 |   margin: 20px 0;
 97 | }
 98 | 
 99 | .content {
100 |   font-size: 18px;
101 |   line-height: 1.6;
102 | }
103 | 
104 | /* 支持 Markdown 格式的文本样式 */
105 | 
106 | /* 标题样式 */
107 | h1, h2, h3, h4, h5, h6 {
108 |   font-weight: bold;
109 |   margin: 20px 0;
110 |   color: #394E6A;
111 | }
112 | 
113 | h1 {
114 |   font-size: 36px;
115 | }
116 | 
117 | h2 {
118 |   font-size: 32px;
119 | }
120 | 
121 | h3 {
122 |   font-size: 28px;
123 | }
124 | 
125 | h4 {
126 |   font-size: 24px;
127 | }
128 | 
129 | h5 {
130 |   font-size: 20px;
131 | }
132 | 
133 | h6 {
134 |   font-size: 18px;
135 | }
136 | 
137 | /* 无序列表 */
138 | ul {
139 |   list-style-type: disc;
140 |   padding-left: 20px;
141 | }
142 | 
143 | ul li {
144 |   margin-bottom: 10px;
145 | }
146 | 
147 | /* 有序列表 */
148 | ol {
149 |   list-style-type: decimal;
150 |   padding-left: 20px;
151 | }
152 | 
153 | ol li {
154 |   margin-bottom: 10px;
155 | }
156 | 
157 | /* 链接 */
158 | a {
159 |   color: #394E6A;
160 |   text-decoration: none;
161 | }
162 | 
163 | a:hover {
164 |   text-decoration: underline;
165 | }
166 | 
167 | /* 加粗 */
168 | strong, b {
169 |   font-weight: bold;
170 | }
171 | 
172 | /* 斜体 */
173 | em, i {
174 |   font-style: italic;
175 | }
176 | 
177 | /* 删除线 */
178 | del {
179 |   text-decoration: line-through;
180 | }
181 | 
182 | /* 代码块 */
183 | pre, code {
184 |   font-family: Consolas, monospace;
185 |   background-color: #f4f4f4;
186 |   border-radius: 0px;
187 |   padding: 5px;
188 | }
189 | 
190 | /* 行内代码 */
191 | code {
192 |   padding: 0px 0px;
193 |   background-color: #e0e0e0;
194 |   border-radius: 0px;
195 | }
196 | 
197 | /* 块引用 */
198 | blockquote {
199 |   border-left: 4px solid #394E6A;
200 |   padding-left: 15px;
201 |   margin: 20px 0;
202 |   font-style: italic;
203 | }
204 | 
205 | /* 表格 */
206 | table {
207 |   width: 100%;
208 |   border-collapse: collapse;
209 |   margin: 20px 0;
210 | }
211 | 
212 | table, th, td {
213 |   border: 1px solid #394E6A;
214 | }
215 | 
216 | th, td {
217 |   padding: 10px;
218 |   text-align: left;
219 | }
220 | 
221 | th {
222 |   background-color: #f0f0f0;
223 | }
224 | 
225 | /* 水平线 */
226 | hr {
227 |   border: 0;
228 |   border-top: 2px solid #394E6A;
229 |   margin: 20px 0;
230 | } 
231 | 
232 | /* 页尾容器 */
233 | .footer-content {
234 |   font-size: 20px; /* 调大字体大小 */
235 |   text-align: center; /* 居中对齐 */
236 | }


--------------------------------------------------------------------------------
/blog.txt:
--------------------------------------------------------------------------------
  1 | @标题：API建成
  2 | 时间：2024.11.08 00:00:00
  3 | 内容：
  4 | 到今天，dan's API项目已经有了3个项目，分别是励志一言，答案之书和塔罗牌（塔罗牌的图片部分还在建）每个API都做了调用次数统计。
  5 | ps:其实php还没完全学会，代码都是`ChatGPT`写的(雾
  6 | ￥￥￥
  7 | @标题：博客重构
  8 | 时间：2024.11.24 00:00:00
  9 | 内容：
 10 | 经过不懈的努力，博客板块从原来的静态网页变成了动态网页！这意味着博文的发布和管理变得更加简化，大大节约了编辑时间。
 11 | 具体说明：博主可通过一个HTML页面编辑博客的标题、内容（支持富文本），输入正确的密码发布博文之后，由后端php处理，将博文存储在web空间里的特定txt文件里。当用户访问博客页面时，通过js读取博文txt内容并呈现在页面上。
 12 | 整个过程不需要数据库支持，大大提高页面加载速度！
 13 | ￥￥￥
 14 | @标题：博客管理升级
 15 | 时间：2024.12.08 00:00:00
 16 | 内容：
 17 | 已支持删除博客功能和发布博客功能，并且把原来的写博客页面和写入存储用的php合并，简化了后端结构。
 18 | 发布和删除都需要经过密码验证，保护了安全
 19 | ￥￥￥
 20 | @标题：支持Markdown!
 21 | 时间：2024.12.29 00:00:00
 22 | 内容：
 23 | <details>
 24 |   <summary>本博客页面已全部支持markdown语法，编辑和写作更加便利！点击查看详细实例</summary>
 25 | 
 26 |   ## 主要内容  
 27 | > #### Markdown*是什么*？  
 28 | > #### *谁*创造了它？  
 29 | > #### *为什么*要使用它？  
 30 | > #### *怎么*使用？  
 31 | > #### *谁*在用？  
 32 | > #### 尝试一下  
 33 | 
 34 | ## 正文
 35 | ### 1. Markdown*是什么*？
 36 | **Markdown**是一种轻量级**标记语言**，它以纯文本形式(*易读、易写、易更改*)编写文档，并最终以HTML格式发布。    
 37 | **Markdown**也可以理解为将以MARKDOWN语法编写的语言转换成HTML内容的工具。    
 38 | 
 39 | ### 2. *谁*创造了它？
 40 | 它由[**Aaron Swartz**](http://www.aaronsw.com/)和**John Gruber**共同设计，**Aaron Swartz**就是那位于去年（*2013年1月11日*）自杀,有着**开挂**一般人生经历的程序员。维基百科对他的[介绍](http://zh.wikipedia.org/wiki/%E4%BA%9A%E4%BC%A6%C2%B7%E6%96%AF%E6%B2%83%E8%8C%A8)是：**软件工程师、作家、政治组织者、互联网活动家、维基百科人**。    
 41 | 
 42 | 他有着足以让你跪拜的人生经历：    
 43 | + **14岁**参与RSS 1.0规格标准的制订。     
 44 | + **2004**年入读**斯坦福**，之后退学。   
 45 | + **2005**年创建[Infogami](http://infogami.org/)，之后与[Reddit](http://www.reddit.com/)合并成为其合伙人。   
 46 | + **2010**年创立求进会（Demand Progress），积极参与禁止网络盗版法案（SOPA）活动，最终该提案被撤回。   
 47 | + **2011**年7月19日，因被控从MIT和JSTOR下载480万篇学术论文并以免费形式上传于网络被捕。     
 48 | + **2013**年1月自杀身亡。    
 49 | 
 50 | ![Aaron Swartz](https://github.com/younghz/Markdown/raw/master/resource/Aaron_Swartz.jpg)
 51 | 
 52 | 天才都有早逝的归途。
 53 | 
 54 | ### 3. *为什么*要使用它？
 55 | + 它是易读（看起来舒服）、易写（语法简单）、易更改**纯文本**。处处体现着**极简主义**的影子。
 56 | + 兼容HTML，可以转换为HTML格式发布。
 57 | + 跨平台使用。
 58 | + 越来越多的网站支持Markdown。
 59 | + 更方便清晰地组织你的电子邮件。（Markdown-here, Airmail）
 60 | + 摆脱Word（我不是认真的）。
 61 | 
 62 | ### 4. *怎么*使用？
 63 | 如果不算**扩展**，Markdown的语法绝对**简单**到让你爱不释手。
 64 | 
 65 | Markdown语法主要分为如下几大部分：
 66 | **标题**，**段落**，**区块引用**，**代码区块**，**强调**，**列表**，**分割线**，**链接**，**图片**，**反斜杠 `\`**，**符号'`'**。
 67 | 
 68 | #### 4.1 标题
 69 | 两种形式：  
 70 | 1）使用`=`和`-`标记一级和二级标题。
 71 | > 一级标题   
 72 | > `=========`   
 73 | > 二级标题    
 74 | > `---------`
 75 | 
 76 | 效果：
 77 | > 一级标题   
 78 | > =========   
 79 | > 二级标题
 80 | > ---------  
 81 | 
 82 | 2）使用`#`，可表示1-6级标题。
 83 | > \# 一级标题   
 84 | > \## 二级标题   
 85 | > \### 三级标题   
 86 | > \#### 四级标题   
 87 | > \##### 五级标题   
 88 | > \###### 六级标题    
 89 | 
 90 | 效果：
 91 | > # 一级标题   
 92 | > ## 二级标题   
 93 | > ### 三级标题   
 94 | > #### 四级标题   
 95 | > ##### 五级标题   
 96 | > ###### 六级标题
 97 | 
 98 | #### 4.2 段落
 99 | 段落的前后要有空行，所谓的空行是指没有文字内容。若想在段内强制换行的方式是使用**两个以上**空格加上回车（引用中换行省略回车）。
100 | 
101 | #### 4.3 区块引用
102 | 在段落的每行或者只在第一行使用符号`>`,还可使用多个嵌套引用，如：
103 | > \> 区块引用  
104 | > \>> 嵌套引用  
105 | 
106 | 效果：
107 | > 区块引用  
108 | >> 嵌套引用
109 | 
110 | #### 4.4 代码区块
111 | 代码区块的建立是在每行加上4个空格或者一个制表符（如同写代码一样）。如    
112 | 普通段落：
113 | 
114 | void main()    
115 | {    
116 |     printf("Hello, Markdown.");    
117 | }    
118 | 
119 | 代码区块：
120 | 
121 |     void main()
122 |     {
123 |         printf("Hello, Markdown.");
124 |     }
125 | 
126 | 
127 | 
128 | **注意**:需要和普通段落之间存在空行。
129 | 
130 | #### 4.5 强调
131 | 在强调内容两侧分别加上`*`或者`_`，如：
132 | > \*斜体\*，\_斜体\_    
133 | > \*\*粗体\*\*，\_\_粗体\_\_
134 | 
135 | 效果：
136 | > *斜体*，_斜体_    
137 | > **粗体**，__粗体__
138 | 
139 | #### 4.6 列表
140 | 使用`·`、`+`、或`-`标记无序列表，如：
141 | > \-（+\*） 第一项
142 | > \-（+\*） 第二项
143 | > \- （+\*）第三项
144 | 
145 | **注意**：标记后面最少有一个_空格_或_制表符_。若不在引用区块中，必须和前方段落之间存在空行。
146 | 
147 | 效果：
148 | > + 第一项
149 | > + 第二项
150 | > + 第三项
151 | 
152 | 有序列表的标记方式是将上述的符号换成数字,并辅以`.`，如：
153 | > 1 . 第一项   
154 | > 2 . 第二项    
155 | > 3 . 第三项    
156 | 
157 | 效果：
158 | > 1. 第一项
159 | > 2. 第二项
160 | > 3. 第三项
161 | 
162 | #### 4.7 分割线
163 | 分割线最常使用就是三个或以上`*`，还可以使用`-`和`_`。
164 | 
165 | #### 4.8 链接
166 | 链接可以由两种形式生成：**行内式**和**参考式**。    
167 | **行内式**：
168 | > \[younghz的Markdown库\]\(https:://github.com/younghz/Markdown "Markdown"\)。
169 | 
170 | 效果：
171 | > [younghz的Markdown库](https:://github.com/younghz/Markdown "Markdown")。
172 | 
173 | **参考式**：
174 | > \[younghz的Markdown库1\]\[1\]    
175 | > \[younghz的Markdown库2\]\[2\]    
176 | > \[1\]:https:://github.com/younghz/Markdown "Markdown"    
177 | > \[2\]:https:://github.com/younghz/Markdown "Markdown"    
178 | 
179 | 效果：
180 | > [younghz的Markdown库1][1]    
181 | > [younghz的Markdown库2][2]
182 | 
183 | [1]: https:://github.com/younghz/Markdown "Markdown"
184 | [2]: https:://github.com/younghz/Markdown "Markdown"
185 | 
186 | **注意**：上述的`[1]:https:://github.com/younghz/Markdown "Markdown"`不出现在区块中。
187 | 
188 | #### 4.9 图片
189 | 添加图片的形式和链接相似，只需在链接的基础上前方加一个`！`。
190 | #### 4.10 反斜杠`\`
191 | 相当于**反转义**作用。使符号成为普通符号。
192 | #### 4.11 符号'`'
193 | 起到标记作用。如：
194 | >\`ctrl+a\`
195 | 
196 | 效果：
197 | >`ctrl+a`    
198 | 
199 | #### 5. *谁*在用？
200 | Markdown的使用者：
201 | + GitHub
202 | + 简书
203 | + Stack Overflow
204 | + Apollo
205 | + Moodle
206 | + Reddit
207 | + 等等
208 | 
209 | #### 6. 尝试一下
210 | + **Chrome**下的插件诸如`stackedit`与`markdown-here`等非常方便，也不用担心平台受限。
211 | + **在线**的dillinger.io评价也不错   
212 | + **Windowns**下的MarkdownPad也用过，不过免费版的体验不是很好。    
213 | + **Mac**下的Mou是国人贡献的，口碑很好。
214 | + **Linux**下的ReText不错。    
215 | 
216 | **当然，最终境界永远都是笔下是语法，心中格式化 :)。**
217 | 
218 | ****
219 | **注意**：不同的Markdown解释器或工具对相应语法（扩展语法）的解释效果不尽相同，具体可参见工具的使用说明。
220 | 虽然有人想出面搞一个所谓的标准化的Markdown，
221 | [没想到还惹怒了健在的创始人John Gruber](http://blog.codinghorror.com/standard-markdown-is-now-common-markdown/ )。
222 | ****
223 | 以上基本是所有traditonal markdown的语法。
224 | 
225 | ### 其它：
226 | 列表的使用(非traditonal markdown)：
227 | 
228 | 用`|`表示表格纵向边界，表头和表内容用`-`隔开，并可用`:`进行对齐设置，两边都有`:`则表示居中，若不加`:`则默认左对齐。
229 | 
230 | |代码库                              |链接                                |
231 | |:------------------------------------:|------------------------------------|
232 | |MarkDown                              |[https://github.com/younghz/Markdown](https://github.com/younghz/Markdown "Markdown")|
233 | |MarkDownCopy                              |[https://github.com/younghz/Markdown](https://github.com/younghz/Markdown "Markdown")|
234 | 
235 | 
236 | 关于其它扩展语法可参见具体工具的使用说明。
237 | </details>
238 | ￥￥￥
239 | @标题：页面优化
240 | 时间：2025.01.01 17:19:08
241 | 内容：
242 | >1.添加博客搜索功能  
243 | >2.博客倒叙排列，新博客在上  
244 | >3.精确时间到秒  
245 | >4.添加部分css使移动端显示优化  
246 | 
247 | 详细信息见[Github仓库](https://github.com/noner-cmd/An-efficient-blog/releases)
248 | ￥￥￥
249 | @标题：速记
250 | 时间：2025.01.22 17:20:37
251 | 内容：
252 | >救赎之道，就在其中
253 | ￥￥￥
254 | @标题：发布页面更新
255 | 时间：2025.01.24 15:28:46
256 | 内容：
257 | 博客发布页面已适配主题风格，同时还加入了`Markdown`快捷键（类似于Github）。使用markdown语法更加便捷！
258 | ![eg](https://egg-dan.space/filebox/file/file_679342da96b66.jpg)
259 | ￥￥￥
260 | @
261 | 标题：布嚎
262 | 时间：2025.01.24 15:41:09
263 | 内容：
264 | 
265 | <details><summary>呜呜呜，似掉了🥺</summary>
266 | 
267 | ![m](https://egg-dan.space/filebox/file/file_679343aecb998.jpg)
268 | 
269 | </details>
270 | ￥￥￥
271 | 


--------------------------------------------------------------------------------
/write.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | // 设置正确的发布密码
  3 | $correctPassword = 'root';
  4 | // 使用哈希密码验证
  5 | // $correctPasswordHash = password_hash('root', PASSWORD_DEFAULT); // 推荐用密码哈希存储
  6 | 
  7 | // 初始化错误消息
  8 | $errorMessage = '';
  9 | 
 10 | // 读取现有的博客内容
 11 | $file = 'blog.txt';
 12 | $blogEntries = [];
 13 | 
 14 | if (file_exists($file)) {
 15 |     $currentContent = file_get_contents($file);
 16 |     // 使用新的分隔符解析博客
 17 |     $rawEntries = explode('@', $currentContent);
 18 | 
 19 |     foreach ($rawEntries as $entry) {
 20 |         $entry = trim($entry); // 去掉首尾空白
 21 |         if (!empty($entry) && str_contains($entry, '￥￥￥')) {
 22 |             $blogEntries[] = "@". $entry; // 保留分隔符
 23 |         }
 24 |     }
 25 | }
 26 | 
 27 | // 检查是否有 POST 请求
 28 | if ($_SERVER['REQUEST_METHOD'] === 'POST') {
 29 |     // 发布新博客
 30 |     if (isset($_POST['title']) && isset($_POST['content']) && isset($_POST['password'])) {
 31 |         $title = $_POST['title'];
 32 |         $content = $_POST['content']; // 使用内容内容
 33 |         $password = $_POST['password'];
 34 |         $date = date('Y.m.d H:i:s'); // 获取当前日期
 35 | 
 36 |         if (empty($title)) {
 37 |             $title = '速记';
 38 |         }
 39 | 
 40 |         if (!empty($content)) {
 41 |             if ($password === $correctPassword) { // 如果用哈希密码，使用 password_verify($password, $correctPasswordHash)
 42 |                 // 格式化博客内容
 43 |                 $blogEntry = "@\n标题：$title\n时间：$date\n内容：\n$content\n￥￥￥";
 44 | 
 45 |                 // 确保现有博客内容末尾有换行符，用于拼接新博客
 46 |                 $currentContent = implode("\n", $blogEntries);
 47 |                 if (!empty($currentContent) &&!str_ends_with($currentContent, "\n")) {
 48 |                     $currentContent.= "\n";
 49 |                 }
 50 | 
 51 |                 // 添加新博客
 52 |                 file_put_contents($file, $currentContent. $blogEntry. "\n");
 53 |                 $errorMessage = '发布成功！';
 54 |                 header('Location: '. $_SERVER['PHP_SELF']. '?error='. urlencode($errorMessage));
 55 |                 exit;
 56 |             } else {
 57 |                 $errorMessage = '密码错误！';
 58 |                 header('Location: '. $_SERVER['PHP_SELF']. '?error='. urlencode($errorMessage));
 59 |                 exit;
 60 |             }
 61 |         } else {
 62 |             $errorMessage = '内容不能为空！';
 63 |             header('Location: '. $_SERVER['PHP_SELF']. '?error='. urlencode($errorMessage));
 64 |             exit;
 65 |         }
 66 |     }
 67 | 
 68 |     // 删除博客
 69 |     if (isset($_POST['delete_index'])) {
 70 |         $deleteIndex = $_POST['delete_index'];
 71 |         $deletePassword = $_POST['delete_password'];
 72 | 
 73 |         if ($deletePassword === $correctPassword) { // 使用哈希密码验证： password_verify($deletePassword, $correctPasswordHash)
 74 |             if (isset($blogEntries[$deleteIndex])) {
 75 |                 unset($blogEntries[$deleteIndex]); // 删除指定博客
 76 |                 $currentContent = implode("\n", $blogEntries); // 重新组合博客内容
 77 |                 file_put_contents($file, $currentContent); // 保存到文件
 78 |                 $errorMessage = '博客删除成功！';
 79 |                 header('Location: '. $_SERVER['PHP_SELF']. '?error='. urlencode($errorMessage));
 80 |                 exit;
 81 |             }
 82 |         } else {
 83 |             $errorMessage = '删除密码错误！';
 84 |             header('Location: '. $_SERVER['PHP_SELF']. '?error='. urlencode($errorMessage));
 85 |             exit;
 86 |         }
 87 |     }
 88 | }
 89 | ?>
 90 | <!DOCTYPE html>
 91 | <html lang="zh-CN">
 92 |     
 93 |     <head>
 94 |         <meta charset="UTF-8">
 95 |         <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
 96 |         <title>
 97 |             发布博客
 98 |         </title>
 99 |         <link rel="stylesheet" href="styles.css">
100 |         <link rel="stylesheet" href="stylespc.css" media="screen and (min-width: 800px)">
101 |         <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
102 |         </header>
103 | <style>
104 | table {
105 |     width: 100%;
106 |     border-collapse: collapse;
107 |     margin-bottom: 20px;
108 |     overflow-x: auto; /* 表格内容超长可滚动 */
109 |     display: block;
110 |     white-space: nowrap;
111 | }
112 | 
113 | th, td {
114 |     border: 1px solid #ddd;
115 |     padding: 10px;
116 |     text-align: left;
117 |     white-space: nowrap;
118 | }
119 | 
120 | th {
121 |     background-color: #f0f0f0;
122 | }
123 | 
124 | hr {
125 |     border: 0;
126 |     border-top: 2px solid #394E6A;
127 |     margin: 20px 0;
128 | }
129 | input[type="text"], textarea, input[type="password"] {
130 |     padding: 8px 12px;
131 |     border: 2px solid #ccc;
132 |     border-radius: 4px;
133 |     width: 90%;
134 |     outline: none;
135 |     transition: border-color 0.3s ease;
136 |     font-family: inherit; /* 继承父元素字体 */
137 |     font-size: inherit; /* 继承父元素字号 */
138 |     color: inherit; /* 继承父元素文字颜色 */
139 |     font-weight: bold;
140 |     margin-bottom: 13px; /* 保留外边距 */
141 | }
142 | table {
143 |     width: 100%;
144 |     table - layout: fixed;
145 |     border - collapse: collapse;
146 | }
147 | 
148 | th,
149 | td {
150 |     width: 50%;
151 |     border: 1px solid #ccc;
152 |     padding: 8px;
153 |     text - align: center;
154 | }
155 | </style>
156 |         <!-- 顶部导航栏 -->
157 |         <header>
158 |             <h1>
159 |                 <a href="https://egg-dan.space/" style="color: #394E6A;text-decoration: none;">
160 |                     📅Dan's Blog
161 |                 </a>
162 |             </h1>
163 |         </header>
164 |         <!-- 主体布局 -->
165 |         <div class="layout">
166 |             <!-- 左侧容器 -->
167 |             <div class="left">
168 |                 <!-- 第一个容器 -->
169 |                 <div class="container">
170 |                     
171 |                     <div class="title">
172 |                         📨发布博客
173 |                     </div>
174 |                 </div>
175 |                 <!-- 第二个容器 -->
176 |                 <div class="container">
177 | 
178 |                     <div class="title">
179 |                         🌐博客列表
180 |                     </div>
181 |                     <div class="content">
182 |         <table>
183 |             <thead>
184 |                 <tr>
185 |                     <th>标题</th>
186 |                     <th>操作</th>
187 |                 </tr>
188 |             </thead>
189 |             <tbody>
190 |                 <?php foreach ($blogEntries as $index => $entry):?>
191 |                     <?php
192 |                     // 解析博客内容
193 |                     preg_match('/标题：(.+?)\n/', $entry, $titleMatch);
194 |                     $title = isset($titleMatch[1])? $titleMatch[1] : '';
195 |                   ?>
196 |                     <tr>
197 |                         <td><?php echo htmlspecialchars($title);?></td>
198 |                         <td>
199 |                             <form action="" method="POST" style="display:inline;">
200 |                                 <input type="hidden" name="delete_index" value="<?php echo $index;?>">
201 |                                 <button type="button" onclick="showDeletePasswordForm(<?php echo $index;?>)">删除</button>
202 |                             </form>
203 |                         </td>
204 |                     </tr>
205 |                 <?php endforeach;?>
206 |             </tbody>
207 |         </table>
208 |                     </div>
209 |                 </div>
210 |     <div class="delete - password - container" id="delete - password - container" style="display: none;">
211 |         <h2>输入密码：</h2>
212 |         <form action="" method="POST">
213 |             <input type="hidden" id="delete_index" name="delete_index" value="">
214 |             <label for="delete_password">删除密码：</label>
215 |             <input type="password" id="delete_password" name="delete_password" required><br>
216 |             <input type="submit" value="删除博客">
217 |         </form>
218 |     </div>
219 |             </div>
220 |             <!-- 右侧容器 -->
221 |             <div class="right">
222 |                 <!-- 第三个容器 -->
223 |                 <div class="container">
224 | 
225 |         <form action="" method="POST">
226 |             <label for="title">标题：</label>
227 |             <input type="text" id="title" name="title"><br>
228 | 
229 |             <label for="content">内容：</label>
230 |             <textarea id="content" name="content" rows="10" cols="50" required></textarea><br>
231 |             <!-- 添加Markdown语法按钮 -->
232 |             <div>
233 |                 <button type="button" onclick="insertMarkdownSyntax('引用', '> ')">引用</button>
234 |                 <button type="button" onclick="insertMarkdownSyntax('行内代码', '`', '`')">行内代码</button>
235 |                 <button type="button" onclick="insertMarkdownSyntax('大标题', '# ')">大标题</button>
236 |                 <button type="button" onclick="insertMarkdownSyntax('代码块', '```', '```')">代码块</button>
237 |                 <button type="button" onclick="insertMarkdownSyntax('图片引用', '![替代文本](图片链接)')">图片引用</button>
238 |                 <button type="button" onclick="insertMarkdownSyntax('链接引用', '[链接文本](链接地址)')">链接引用</button>
239 |                 <button type="button" onclick="insertMarkdownSyntax('加粗', '**', '**')">加粗</button>
240 |                 <button type="button" onclick="insertMarkdownSyntax('斜体', '*', '*')">斜体</button>
241 |                 <button type="button" onclick="insertMarkdownSyntax('分割线', '---')">分割线</button>
242 |                 <button type="button" onclick="insertMarkdownSyntax('折叠', '<details><summary>摘要</summary>\n\n内容\n\n</details>')">折叠</button>
243 |                 <button type="button" onclick="insertMarkdownSyntax('无序列表', '- ')">无序列表</button>
244 |                 <button type="button" onclick="insertMarkdownSyntax('有序列表', '1. ')">有序列表</button>
245 |                 <button type="button" onclick="insertMarkdownSyntax('表格', '| 列1 | 列2 |\n| ---- | ---- |\n| 内容1 | 内容2 |')">表格</button>
246 |             </div>
247 | 
248 |             <label for="password">密码：</label>
249 |             <input type="password" id="password" name="password" required><br>
250 | 
251 |             <input type="submit" value="发布博客">
252 |         </form>
253 |     </div>
254 | 
255 | 
256 |             </div>
257 |         </div>
258 |         </body>
259 |         <!-- JavaScript -->
260 |     <script>
261 |         // 弹窗提示
262 |         <?php if (isset($_GET['error'])):?>
263 |             alert('<?php echo htmlspecialchars($_GET['error']);?>');
264 |         <?php endif;?>
265 | 
266 |         // 显示删除密码输入框
267 |         function showDeletePasswordForm(index) {
268 |             document.getElementById('delete - password - container').style.display = 'block';
269 |             document.getElementById('delete_index').value = index;
270 |         }
271 | 
272 |         // 插入Markdown语法到文本域
273 |         function insertMarkdownSyntax(name, start, end = '') {
274 |             const textarea = document.getElementById('content');
275 |             const startIndex = textarea.selectionStart;
276 |             const endIndex = textarea.selectionEnd;
277 |             const before = textarea.value.substring(0, startIndex);
278 |             const selected = textarea.value.substring(startIndex, endIndex);
279 |             const after = textarea.value.substring(endIndex);
280 |             if (name === '行内代码' && selected) {
281 |                 start = '`' + selected + '`';
282 |                 end = '';
283 |             }
284 |             textarea.value = before + start + end + after;
285 |             textarea.selectionStart = before.length + start.length;
286 |             textarea.selectionEnd = before.length + start.length;
287 |         }
288 |     </script>
289 | 
290 | 
291 | </html>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------
/Parsedown.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | 
   3 | #
   4 | #
   5 | # Parsedown
   6 | # http://parsedown.org
   7 | #
   8 | # (c) Emanuil Rusev
   9 | # http://erusev.com
  10 | #
  11 | # For the full license information, view the LICENSE file that was distributed
  12 | # with this source code.
  13 | #
  14 | #
  15 | 
  16 | class Parsedown
  17 | {
  18 |     # ~
  19 | 
  20 |     const version = '1.8.0';
  21 | 
  22 |     # ~
  23 | 
  24 |     function text($text)
  25 |     {
  26 |         $Elements = $this->textElements($text);
  27 | 
  28 |         # convert to markup
  29 |         $markup = $this->elements($Elements);
  30 | 
  31 |         # trim line breaks
  32 |         $markup = trim($markup, "\n");
  33 | 
  34 |         return $markup;
  35 |     }
  36 | 
  37 |     protected function textElements($text)
  38 |     {
  39 |         # make sure no definitions are set
  40 |         $this->DefinitionData = array();
  41 | 
  42 |         # standardize line breaks
  43 |         $text = str_replace(array("\r\n", "\r"), "\n", $text);
  44 | 
  45 |         # remove surrounding line breaks
  46 |         $text = trim($text, "\n");
  47 | 
  48 |         # split text into lines
  49 |         $lines = explode("\n", $text);
  50 | 
  51 |         # iterate through lines to identify blocks
  52 |         return $this->linesElements($lines);
  53 |     }
  54 | 
  55 |     #
  56 |     # Setters
  57 |     #
  58 | 
  59 |     function setBreaksEnabled($breaksEnabled)
  60 |     {
  61 |         $this->breaksEnabled = $breaksEnabled;
  62 | 
  63 |         return $this;
  64 |     }
  65 | 
  66 |     protected $breaksEnabled;
  67 | 
  68 |     function setMarkupEscaped($markupEscaped)
  69 |     {
  70 |         $this->markupEscaped = $markupEscaped;
  71 | 
  72 |         return $this;
  73 |     }
  74 | 
  75 |     protected $markupEscaped;
  76 | 
  77 |     function setUrlsLinked($urlsLinked)
  78 |     {
  79 |         $this->urlsLinked = $urlsLinked;
  80 | 
  81 |         return $this;
  82 |     }
  83 | 
  84 |     protected $urlsLinked = true;
  85 | 
  86 |     function setSafeMode($safeMode)
  87 |     {
  88 |         $this->safeMode = (bool) $safeMode;
  89 | 
  90 |         return $this;
  91 |     }
  92 | 
  93 |     protected $safeMode;
  94 | 
  95 |     function setStrictMode($strictMode)
  96 |     {
  97 |         $this->strictMode = (bool) $strictMode;
  98 | 
  99 |         return $this;
 100 |     }
 101 | 
 102 |     protected $strictMode;
 103 | 
 104 |     protected $safeLinksWhitelist = array(
 105 |         'http://',
 106 |         'https://',
 107 |         'ftp://',
 108 |         'ftps://',
 109 |         'mailto:',
 110 |         'tel:',
 111 |         'data:image/png;base64,',
 112 |         'data:image/gif;base64,',
 113 |         'data:image/jpeg;base64,',
 114 |         'irc:',
 115 |         'ircs:',
 116 |         'git:',
 117 |         'ssh:',
 118 |         'news:',
 119 |         'steam:',
 120 |     );
 121 | 
 122 |     #
 123 |     # Lines
 124 |     #
 125 | 
 126 |     protected $BlockTypes = array(
 127 |         '#' => array('Header'),
 128 |         '*' => array('Rule', 'List'),
 129 |         '+' => array('List'),
 130 |         '-' => array('SetextHeader', 'Table', 'Rule', 'List'),
 131 |         '0' => array('List'),
 132 |         '1' => array('List'),
 133 |         '2' => array('List'),
 134 |         '3' => array('List'),
 135 |         '4' => array('List'),
 136 |         '5' => array('List'),
 137 |         '6' => array('List'),
 138 |         '7' => array('List'),
 139 |         '8' => array('List'),
 140 |         '9' => array('List'),
 141 |         ':' => array('Table'),
 142 |         '<' => array('Comment', 'Markup'),
 143 |         '=' => array('SetextHeader'),
 144 |         '>' => array('Quote'),
 145 |         '[' => array('Reference'),
 146 |         '_' => array('Rule'),
 147 |         '`' => array('FencedCode'),
 148 |         '|' => array('Table'),
 149 |         '~' => array('FencedCode'),
 150 |     );
 151 | 
 152 |     # ~
 153 | 
 154 |     protected $unmarkedBlockTypes = array(
 155 |         'Code',
 156 |     );
 157 | 
 158 |     #
 159 |     # Blocks
 160 |     #
 161 | 
 162 |     protected function lines(array $lines)
 163 |     {
 164 |         return $this->elements($this->linesElements($lines));
 165 |     }
 166 | 
 167 |     protected function linesElements(array $lines)
 168 |     {
 169 |         $Elements = array();
 170 |         $CurrentBlock = null;
 171 | 
 172 |         foreach ($lines as $line)
 173 |         {
 174 |             if (chop($line) === '')
 175 |             {
 176 |                 if (isset($CurrentBlock))
 177 |                 {
 178 |                     $CurrentBlock['interrupted'] = (isset($CurrentBlock['interrupted'])
 179 |                         ? $CurrentBlock['interrupted'] + 1 : 1
 180 |                     );
 181 |                 }
 182 | 
 183 |                 continue;
 184 |             }
 185 | 
 186 |             while (($beforeTab = strstr($line, "\t", true)) !== false)
 187 |             {
 188 |                 $shortage = 4 - mb_strlen($beforeTab, 'utf-8') % 4;
 189 | 
 190 |                 $line = $beforeTab
 191 |                     . str_repeat(' ', $shortage)
 192 |                     . substr($line, strlen($beforeTab) + 1)
 193 |                 ;
 194 |             }
 195 | 
 196 |             $indent = strspn($line, ' ');
 197 | 
 198 |             $text = $indent > 0 ? substr($line, $indent) : $line;
 199 | 
 200 |             # ~
 201 | 
 202 |             $Line = array('body' => $line, 'indent' => $indent, 'text' => $text);
 203 | 
 204 |             # ~
 205 | 
 206 |             if (isset($CurrentBlock['continuable']))
 207 |             {
 208 |                 $methodName = 'block' . $CurrentBlock['type'] . 'Continue';
 209 |                 $Block = $this->$methodName($Line, $CurrentBlock);
 210 | 
 211 |                 if (isset($Block))
 212 |                 {
 213 |                     $CurrentBlock = $Block;
 214 | 
 215 |                     continue;
 216 |                 }
 217 |                 else
 218 |                 {
 219 |                     if ($this->isBlockCompletable($CurrentBlock['type']))
 220 |                     {
 221 |                         $methodName = 'block' . $CurrentBlock['type'] . 'Complete';
 222 |                         $CurrentBlock = $this->$methodName($CurrentBlock);
 223 |                     }
 224 |                 }
 225 |             }
 226 | 
 227 |             # ~
 228 | 
 229 |             $marker = $text[0];
 230 | 
 231 |             # ~
 232 | 
 233 |             $blockTypes = $this->unmarkedBlockTypes;
 234 | 
 235 |             if (isset($this->BlockTypes[$marker]))
 236 |             {
 237 |                 foreach ($this->BlockTypes[$marker] as $blockType)
 238 |                 {
 239 |                     $blockTypes []= $blockType;
 240 |                 }
 241 |             }
 242 | 
 243 |             #
 244 |             # ~
 245 | 
 246 |             foreach ($blockTypes as $blockType)
 247 |             {
 248 |                 $Block = $this->{"block$blockType"}($Line, $CurrentBlock);
 249 | 
 250 |                 if (isset($Block))
 251 |                 {
 252 |                     $Block['type'] = $blockType;
 253 | 
 254 |                     if ( ! isset($Block['identified']))
 255 |                     {
 256 |                         if (isset($CurrentBlock))
 257 |                         {
 258 |                             $Elements[] = $this->extractElement($CurrentBlock);
 259 |                         }
 260 | 
 261 |                         $Block['identified'] = true;
 262 |                     }
 263 | 
 264 |                     if ($this->isBlockContinuable($blockType))
 265 |                     {
 266 |                         $Block['continuable'] = true;
 267 |                     }
 268 | 
 269 |                     $CurrentBlock = $Block;
 270 | 
 271 |                     continue 2;
 272 |                 }
 273 |             }
 274 | 
 275 |             # ~
 276 | 
 277 |             if (isset($CurrentBlock) and $CurrentBlock['type'] === 'Paragraph')
 278 |             {
 279 |                 $Block = $this->paragraphContinue($Line, $CurrentBlock);
 280 |             }
 281 | 
 282 |             if (isset($Block))
 283 |             {
 284 |                 $CurrentBlock = $Block;
 285 |             }
 286 |             else
 287 |             {
 288 |                 if (isset($CurrentBlock))
 289 |                 {
 290 |                     $Elements[] = $this->extractElement($CurrentBlock);
 291 |                 }
 292 | 
 293 |                 $CurrentBlock = $this->paragraph($Line);
 294 | 
 295 |                 $CurrentBlock['identified'] = true;
 296 |             }
 297 |         }
 298 | 
 299 |         # ~
 300 | 
 301 |         if (isset($CurrentBlock['continuable']) and $this->isBlockCompletable($CurrentBlock['type']))
 302 |         {
 303 |             $methodName = 'block' . $CurrentBlock['type'] . 'Complete';
 304 |             $CurrentBlock = $this->$methodName($CurrentBlock);
 305 |         }
 306 | 
 307 |         # ~
 308 | 
 309 |         if (isset($CurrentBlock))
 310 |         {
 311 |             $Elements[] = $this->extractElement($CurrentBlock);
 312 |         }
 313 | 
 314 |         # ~
 315 | 
 316 |         return $Elements;
 317 |     }
 318 | 
 319 |     protected function extractElement(array $Component)
 320 |     {
 321 |         if ( ! isset($Component['element']))
 322 |         {
 323 |             if (isset($Component['markup']))
 324 |             {
 325 |                 $Component['element'] = array('rawHtml' => $Component['markup']);
 326 |             }
 327 |             elseif (isset($Component['hidden']))
 328 |             {
 329 |                 $Component['element'] = array();
 330 |             }
 331 |         }
 332 | 
 333 |         return $Component['element'];
 334 |     }
 335 | 
 336 |     protected function isBlockContinuable($Type)
 337 |     {
 338 |         return method_exists($this, 'block' . $Type . 'Continue');
 339 |     }
 340 | 
 341 |     protected function isBlockCompletable($Type)
 342 |     {
 343 |         return method_exists($this, 'block' . $Type . 'Complete');
 344 |     }
 345 | 
 346 |     #
 347 |     # Code
 348 | 
 349 |     protected function blockCode($Line, $Block = null)
 350 |     {
 351 |         if (isset($Block) and $Block['type'] === 'Paragraph' and ! isset($Block['interrupted']))
 352 |         {
 353 |             return;
 354 |         }
 355 | 
 356 |         if ($Line['indent'] >= 4)
 357 |         {
 358 |             $text = substr($Line['body'], 4);
 359 | 
 360 |             $Block = array(
 361 |                 'element' => array(
 362 |                     'name' => 'pre',
 363 |                     'element' => array(
 364 |                         'name' => 'code',
 365 |                         'text' => $text,
 366 |                     ),
 367 |                 ),
 368 |             );
 369 | 
 370 |             return $Block;
 371 |         }
 372 |     }
 373 | 
 374 |     protected function blockCodeContinue($Line, $Block)
 375 |     {
 376 |         if ($Line['indent'] >= 4)
 377 |         {
 378 |             if (isset($Block['interrupted']))
 379 |             {
 380 |                 $Block['element']['element']['text'] .= str_repeat("\n", $Block['interrupted']);
 381 | 
 382 |                 unset($Block['interrupted']);
 383 |             }
 384 | 
 385 |             $Block['element']['element']['text'] .= "\n";
 386 | 
 387 |             $text = substr($Line['body'], 4);
 388 | 
 389 |             $Block['element']['element']['text'] .= $text;
 390 | 
 391 |             return $Block;
 392 |         }
 393 |     }
 394 | 
 395 |     protected function blockCodeComplete($Block)
 396 |     {
 397 |         return $Block;
 398 |     }
 399 | 
 400 |     #
 401 |     # Comment
 402 | 
 403 |     protected function blockComment($Line)
 404 |     {
 405 |         if ($this->markupEscaped or $this->safeMode)
 406 |         {
 407 |             return;
 408 |         }
 409 | 
 410 |         if (strpos($Line['text'], '<!--') === 0)
 411 |         {
 412 |             $Block = array(
 413 |                 'element' => array(
 414 |                     'rawHtml' => $Line['body'],
 415 |                     'autobreak' => true,
 416 |                 ),
 417 |             );
 418 | 
 419 |             if (strpos($Line['text'], '-->') !== false)
 420 |             {
 421 |                 $Block['closed'] = true;
 422 |             }
 423 | 
 424 |             return $Block;
 425 |         }
 426 |     }
 427 | 
 428 |     protected function blockCommentContinue($Line, array $Block)
 429 |     {
 430 |         if (isset($Block['closed']))
 431 |         {
 432 |             return;
 433 |         }
 434 | 
 435 |         $Block['element']['rawHtml'] .= "\n" . $Line['body'];
 436 | 
 437 |         if (strpos($Line['text'], '-->') !== false)
 438 |         {
 439 |             $Block['closed'] = true;
 440 |         }
 441 | 
 442 |         return $Block;
 443 |     }
 444 | 
 445 |     #
 446 |     # Fenced Code
 447 | 
 448 |     protected function blockFencedCode($Line)
 449 |     {
 450 |         $marker = $Line['text'][0];
 451 | 
 452 |         $openerLength = strspn($Line['text'], $marker);
 453 | 
 454 |         if ($openerLength < 3)
 455 |         {
 456 |             return;
 457 |         }
 458 | 
 459 |         $infostring = trim(substr($Line['text'], $openerLength), "\t ");
 460 | 
 461 |         if (strpos($infostring, '`') !== false)
 462 |         {
 463 |             return;
 464 |         }
 465 | 
 466 |         $Element = array(
 467 |             'name' => 'code',
 468 |             'text' => '',
 469 |         );
 470 | 
 471 |         if ($infostring !== '')
 472 |         {
 473 |             /**
 474 |              * https://www.w3.org/TR/2011/WD-html5-20110525/elements.html#classes
 475 |              * Every HTML element may have a class attribute specified.
 476 |              * The attribute, if specified, must have a value that is a set
 477 |              * of space-separated tokens representing the various classes
 478 |              * that the element belongs to.
 479 |              * [...]
 480 |              * The space characters, for the purposes of this specification,
 481 |              * are U+0020 SPACE, U+0009 CHARACTER TABULATION (tab),
 482 |              * U+000A LINE FEED (LF), U+000C FORM FEED (FF), and
 483 |              * U+000D CARRIAGE RETURN (CR).
 484 |              */
 485 |             $language = substr($infostring, 0, strcspn($infostring, " \t\n\f\r"));
 486 | 
 487 |             $Element['attributes'] = array('class' => "language-$language");
 488 |         }
 489 | 
 490 |         $Block = array(
 491 |             'char' => $marker,
 492 |             'openerLength' => $openerLength,
 493 |             'element' => array(
 494 |                 'name' => 'pre',
 495 |                 'element' => $Element,
 496 |             ),
 497 |         );
 498 | 
 499 |         return $Block;
 500 |     }
 501 | 
 502 |     protected function blockFencedCodeContinue($Line, $Block)
 503 |     {
 504 |         if (isset($Block['complete']))
 505 |         {
 506 |             return;
 507 |         }
 508 | 
 509 |         if (isset($Block['interrupted']))
 510 |         {
 511 |             $Block['element']['element']['text'] .= str_repeat("\n", $Block['interrupted']);
 512 | 
 513 |             unset($Block['interrupted']);
 514 |         }
 515 | 
 516 |         if (($len = strspn($Line['text'], $Block['char'])) >= $Block['openerLength']
 517 |             and chop(substr($Line['text'], $len), ' ') === ''
 518 |         ) {
 519 |             $Block['element']['element']['text'] = substr($Block['element']['element']['text'], 1);
 520 | 
 521 |             $Block['complete'] = true;
 522 | 
 523 |             return $Block;
 524 |         }
 525 | 
 526 |         $Block['element']['element']['text'] .= "\n" . $Line['body'];
 527 | 
 528 |         return $Block;
 529 |     }
 530 | 
 531 |     protected function blockFencedCodeComplete($Block)
 532 |     {
 533 |         return $Block;
 534 |     }
 535 | 
 536 |     #
 537 |     # Header
 538 | 
 539 |     protected function blockHeader($Line)
 540 |     {
 541 |         $level = strspn($Line['text'], '#');
 542 | 
 543 |         if ($level > 6)
 544 |         {
 545 |             return;
 546 |         }
 547 | 
 548 |         $text = trim($Line['text'], '#');
 549 | 
 550 |         if ($this->strictMode and isset($text[0]) and $text[0] !== ' ')
 551 |         {
 552 |             return;
 553 |         }
 554 | 
 555 |         $text = trim($text, ' ');
 556 | 
 557 |         $Block = array(
 558 |             'element' => array(
 559 |                 'name' => 'h' . $level,
 560 |                 'handler' => array(
 561 |                     'function' => 'lineElements',
 562 |                     'argument' => $text,
 563 |                     'destination' => 'elements',
 564 |                 )
 565 |             ),
 566 |         );
 567 | 
 568 |         return $Block;
 569 |     }
 570 | 
 571 |     #
 572 |     # List
 573 | 
 574 |     protected function blockList($Line, ?array $CurrentBlock = null)
 575 |     {
 576 |         list($name, $pattern) = $Line['text'][0] <= '-' ? array('ul', '[*+-]') : array('ol', '[0-9]{1,9}+[.\)]');
 577 | 
 578 |         if (preg_match('/^('.$pattern.'([ ]++|$))(.*+)/', $Line['text'], $matches))
 579 |         {
 580 |             $contentIndent = strlen($matches[2]);
 581 | 
 582 |             if ($contentIndent >= 5)
 583 |             {
 584 |                 $contentIndent -= 1;
 585 |                 $matches[1] = substr($matches[1], 0, -$contentIndent);
 586 |                 $matches[3] = str_repeat(' ', $contentIndent) . $matches[3];
 587 |             }
 588 |             elseif ($contentIndent === 0)
 589 |             {
 590 |                 $matches[1] .= ' ';
 591 |             }
 592 | 
 593 |             $markerWithoutWhitespace = strstr($matches[1], ' ', true);
 594 | 
 595 |             $Block = array(
 596 |                 'indent' => $Line['indent'],
 597 |                 'pattern' => $pattern,
 598 |                 'data' => array(
 599 |                     'type' => $name,
 600 |                     'marker' => $matches[1],
 601 |                     'markerType' => ($name === 'ul' ? $markerWithoutWhitespace : substr($markerWithoutWhitespace, -1)),
 602 |                 ),
 603 |                 'element' => array(
 604 |                     'name' => $name,
 605 |                     'elements' => array(),
 606 |                 ),
 607 |             );
 608 |             $Block['data']['markerTypeRegex'] = preg_quote($Block['data']['markerType'], '/');
 609 | 
 610 |             if ($name === 'ol')
 611 |             {
 612 |                 $listStart = ltrim(strstr($matches[1], $Block['data']['markerType'], true), '0') ?: '0';
 613 | 
 614 |                 if ($listStart !== '1')
 615 |                 {
 616 |                     if (
 617 |                         isset($CurrentBlock)
 618 |                         and $CurrentBlock['type'] === 'Paragraph'
 619 |                         and ! isset($CurrentBlock['interrupted'])
 620 |                     ) {
 621 |                         return;
 622 |                     }
 623 | 
 624 |                     $Block['element']['attributes'] = array('start' => $listStart);
 625 |                 }
 626 |             }
 627 | 
 628 |             $Block['li'] = array(
 629 |                 'name' => 'li',
 630 |                 'handler' => array(
 631 |                     'function' => 'li',
 632 |                     'argument' => !empty($matches[3]) ? array($matches[3]) : array(),
 633 |                     'destination' => 'elements'
 634 |                 )
 635 |             );
 636 | 
 637 |             $Block['element']['elements'] []= & $Block['li'];
 638 | 
 639 |             return $Block;
 640 |         }
 641 |     }
 642 | 
 643 |     protected function blockListContinue($Line, array $Block)
 644 |     {
 645 |         if (isset($Block['interrupted']) and empty($Block['li']['handler']['argument']))
 646 |         {
 647 |             return null;
 648 |         }
 649 | 
 650 |         $requiredIndent = ($Block['indent'] + strlen($Block['data']['marker']));
 651 | 
 652 |         if ($Line['indent'] < $requiredIndent
 653 |             and (
 654 |                 (
 655 |                     $Block['data']['type'] === 'ol'
 656 |                     and preg_match('/^[0-9]++'.$Block['data']['markerTypeRegex'].'(?:[ ]++(.*)|$)/', $Line['text'], $matches)
 657 |                 ) or (
 658 |                     $Block['data']['type'] === 'ul'
 659 |                     and preg_match('/^'.$Block['data']['markerTypeRegex'].'(?:[ ]++(.*)|$)/', $Line['text'], $matches)
 660 |                 )
 661 |             )
 662 |         ) {
 663 |             if (isset($Block['interrupted']))
 664 |             {
 665 |                 $Block['li']['handler']['argument'] []= '';
 666 | 
 667 |                 $Block['loose'] = true;
 668 | 
 669 |                 unset($Block['interrupted']);
 670 |             }
 671 | 
 672 |             unset($Block['li']);
 673 | 
 674 |             $text = isset($matches[1]) ? $matches[1] : '';
 675 | 
 676 |             $Block['indent'] = $Line['indent'];
 677 | 
 678 |             $Block['li'] = array(
 679 |                 'name' => 'li',
 680 |                 'handler' => array(
 681 |                     'function' => 'li',
 682 |                     'argument' => array($text),
 683 |                     'destination' => 'elements'
 684 |                 )
 685 |             );
 686 | 
 687 |             $Block['element']['elements'] []= & $Block['li'];
 688 | 
 689 |             return $Block;
 690 |         }
 691 |         elseif ($Line['indent'] < $requiredIndent and $this->blockList($Line))
 692 |         {
 693 |             return null;
 694 |         }
 695 | 
 696 |         if ($Line['text'][0] === '[' and $this->blockReference($Line))
 697 |         {
 698 |             return $Block;
 699 |         }
 700 | 
 701 |         if ($Line['indent'] >= $requiredIndent)
 702 |         {
 703 |             if (isset($Block['interrupted']))
 704 |             {
 705 |                 $Block['li']['handler']['argument'] []= '';
 706 | 
 707 |                 $Block['loose'] = true;
 708 | 
 709 |                 unset($Block['interrupted']);
 710 |             }
 711 | 
 712 |             $text = substr($Line['body'], $requiredIndent);
 713 | 
 714 |             $Block['li']['handler']['argument'] []= $text;
 715 | 
 716 |             return $Block;
 717 |         }
 718 | 
 719 |         if ( ! isset($Block['interrupted']))
 720 |         {
 721 |             $text = preg_replace('/^[ ]{0,'.$requiredIndent.'}+/', '', $Line['body']);
 722 | 
 723 |             $Block['li']['handler']['argument'] []= $text;
 724 | 
 725 |             return $Block;
 726 |         }
 727 |     }
 728 | 
 729 |     protected function blockListComplete(array $Block)
 730 |     {
 731 |         if (isset($Block['loose']))
 732 |         {
 733 |             foreach ($Block['element']['elements'] as &$li)
 734 |             {
 735 |                 if (end($li['handler']['argument']) !== '')
 736 |                 {
 737 |                     $li['handler']['argument'] []= '';
 738 |                 }
 739 |             }
 740 |         }
 741 | 
 742 |         return $Block;
 743 |     }
 744 | 
 745 |     #
 746 |     # Quote
 747 | 
 748 |     protected function blockQuote($Line)
 749 |     {
 750 |         if (preg_match('/^>[ ]?+(.*+)/', $Line['text'], $matches))
 751 |         {
 752 |             $Block = array(
 753 |                 'element' => array(
 754 |                     'name' => 'blockquote',
 755 |                     'handler' => array(
 756 |                         'function' => 'linesElements',
 757 |                         'argument' => (array) $matches[1],
 758 |                         'destination' => 'elements',
 759 |                     )
 760 |                 ),
 761 |             );
 762 | 
 763 |             return $Block;
 764 |         }
 765 |     }
 766 | 
 767 |     protected function blockQuoteContinue($Line, array $Block)
 768 |     {
 769 |         if (isset($Block['interrupted']))
 770 |         {
 771 |             return;
 772 |         }
 773 | 
 774 |         if ($Line['text'][0] === '>' and preg_match('/^>[ ]?+(.*+)/', $Line['text'], $matches))
 775 |         {
 776 |             $Block['element']['handler']['argument'] []= $matches[1];
 777 | 
 778 |             return $Block;
 779 |         }
 780 | 
 781 |         if ( ! isset($Block['interrupted']))
 782 |         {
 783 |             $Block['element']['handler']['argument'] []= $Line['text'];
 784 | 
 785 |             return $Block;
 786 |         }
 787 |     }
 788 | 
 789 |     #
 790 |     # Rule
 791 | 
 792 |     protected function blockRule($Line)
 793 |     {
 794 |         $marker = $Line['text'][0];
 795 | 
 796 |         if (substr_count($Line['text'], $marker) >= 3 and chop($Line['text'], " $marker") === '')
 797 |         {
 798 |             $Block = array(
 799 |                 'element' => array(
 800 |                     'name' => 'hr',
 801 |                 ),
 802 |             );
 803 | 
 804 |             return $Block;
 805 |         }
 806 |     }
 807 | 
 808 |     #
 809 |     # Setext
 810 | 
 811 |     protected function blockSetextHeader($Line, ?array $Block = null)
 812 |     {
 813 |         if ( ! isset($Block) or $Block['type'] !== 'Paragraph' or isset($Block['interrupted']))
 814 |         {
 815 |             return;
 816 |         }
 817 | 
 818 |         if ($Line['indent'] < 4 and chop(chop($Line['text'], ' '), $Line['text'][0]) === '')
 819 |         {
 820 |             $Block['element']['name'] = $Line['text'][0] === '=' ? 'h1' : 'h2';
 821 | 
 822 |             return $Block;
 823 |         }
 824 |     }
 825 | 
 826 |     #
 827 |     # Markup
 828 | 
 829 |     protected function blockMarkup($Line)
 830 |     {
 831 |         if ($this->markupEscaped or $this->safeMode)
 832 |         {
 833 |             return;
 834 |         }
 835 | 
 836 |         if (preg_match('/^<[\/]?+(\w*)(?:[ ]*+'.$this->regexHtmlAttribute.')*+[ ]*+(\/)?>/', $Line['text'], $matches))
 837 |         {
 838 |             $element = strtolower($matches[1]);
 839 | 
 840 |             if (in_array($element, $this->textLevelElements))
 841 |             {
 842 |                 return;
 843 |             }
 844 | 
 845 |             $Block = array(
 846 |                 'name' => $matches[1],
 847 |                 'element' => array(
 848 |                     'rawHtml' => $Line['text'],
 849 |                     'autobreak' => true,
 850 |                 ),
 851 |             );
 852 | 
 853 |             return $Block;
 854 |         }
 855 |     }
 856 | 
 857 |     protected function blockMarkupContinue($Line, array $Block)
 858 |     {
 859 |         if (isset($Block['closed']) or isset($Block['interrupted']))
 860 |         {
 861 |             return;
 862 |         }
 863 | 
 864 |         $Block['element']['rawHtml'] .= "\n" . $Line['body'];
 865 | 
 866 |         return $Block;
 867 |     }
 868 | 
 869 |     #
 870 |     # Reference
 871 | 
 872 |     protected function blockReference($Line)
 873 |     {
 874 |         if (strpos($Line['text'], ']') !== false
 875 |             and preg_match('/^\[(.+?)\]:[ ]*+<?(\S+?)>?(?:[ ]+["\'(](.+)["\')])?[ ]*+$/', $Line['text'], $matches)
 876 |         ) {
 877 |             $id = strtolower($matches[1]);
 878 | 
 879 |             $Data = array(
 880 |                 'url' => $matches[2],
 881 |                 'title' => isset($matches[3]) ? $matches[3] : null,
 882 |             );
 883 | 
 884 |             $this->DefinitionData['Reference'][$id] = $Data;
 885 | 
 886 |             $Block = array(
 887 |                 'element' => array(),
 888 |             );
 889 | 
 890 |             return $Block;
 891 |         }
 892 |     }
 893 | 
 894 |     #
 895 |     # Table
 896 | 
 897 |     protected function blockTable($Line, ?array $Block = null)
 898 |     {
 899 |         if ( ! isset($Block) or $Block['type'] !== 'Paragraph' or isset($Block['interrupted']))
 900 |         {
 901 |             return;
 902 |         }
 903 | 
 904 |         if (
 905 |             strpos($Block['element']['handler']['argument'], '|') === false
 906 |             and strpos($Line['text'], '|') === false
 907 |             and strpos($Line['text'], ':') === false
 908 |             or strpos($Block['element']['handler']['argument'], "\n") !== false
 909 |         ) {
 910 |             return;
 911 |         }
 912 | 
 913 |         if (chop($Line['text'], ' -:|') !== '')
 914 |         {
 915 |             return;
 916 |         }
 917 | 
 918 |         $alignments = array();
 919 | 
 920 |         $divider = $Line['text'];
 921 | 
 922 |         $divider = trim($divider);
 923 |         $divider = trim($divider, '|');
 924 | 
 925 |         $dividerCells = explode('|', $divider);
 926 | 
 927 |         foreach ($dividerCells as $dividerCell)
 928 |         {
 929 |             $dividerCell = trim($dividerCell);
 930 | 
 931 |             if ($dividerCell === '')
 932 |             {
 933 |                 return;
 934 |             }
 935 | 
 936 |             $alignment = null;
 937 | 
 938 |             if ($dividerCell[0] === ':')
 939 |             {
 940 |                 $alignment = 'left';
 941 |             }
 942 | 
 943 |             if (substr($dividerCell, - 1) === ':')
 944 |             {
 945 |                 $alignment = $alignment === 'left' ? 'center' : 'right';
 946 |             }
 947 | 
 948 |             $alignments []= $alignment;
 949 |         }
 950 | 
 951 |         # ~
 952 | 
 953 |         $HeaderElements = array();
 954 | 
 955 |         $header = $Block['element']['handler']['argument'];
 956 | 
 957 |         $header = trim($header);
 958 |         $header = trim($header, '|');
 959 | 
 960 |         $headerCells = explode('|', $header);
 961 | 
 962 |         if (count($headerCells) !== count($alignments))
 963 |         {
 964 |             return;
 965 |         }
 966 | 
 967 |         foreach ($headerCells as $index => $headerCell)
 968 |         {
 969 |             $headerCell = trim($headerCell);
 970 | 
 971 |             $HeaderElement = array(
 972 |                 'name' => 'th',
 973 |                 'handler' => array(
 974 |                     'function' => 'lineElements',
 975 |                     'argument' => $headerCell,
 976 |                     'destination' => 'elements',
 977 |                 )
 978 |             );
 979 | 
 980 |             if (isset($alignments[$index]))
 981 |             {
 982 |                 $alignment = $alignments[$index];
 983 | 
 984 |                 $HeaderElement['attributes'] = array(
 985 |                     'style' => "text-align: $alignment;",
 986 |                 );
 987 |             }
 988 | 
 989 |             $HeaderElements []= $HeaderElement;
 990 |         }
 991 | 
 992 |         # ~
 993 | 
 994 |         $Block = array(
 995 |             'alignments' => $alignments,
 996 |             'identified' => true,
 997 |             'element' => array(
 998 |                 'name' => 'table',
 999 |                 'elements' => array(),
1000 |             ),
1001 |         );
1002 | 
1003 |         $Block['element']['elements'] []= array(
1004 |             'name' => 'thead',
1005 |         );
1006 | 
1007 |         $Block['element']['elements'] []= array(
1008 |             'name' => 'tbody',
1009 |             'elements' => array(),
1010 |         );
1011 | 
1012 |         $Block['element']['elements'][0]['elements'] []= array(
1013 |             'name' => 'tr',
1014 |             'elements' => $HeaderElements,
1015 |         );
1016 | 
1017 |         return $Block;
1018 |     }
1019 | 
1020 |     protected function blockTableContinue($Line, array $Block)
1021 |     {
1022 |         if (isset($Block['interrupted']))
1023 |         {
1024 |             return;
1025 |         }
1026 | 
1027 |         if (count($Block['alignments']) === 1 or $Line['text'][0] === '|' or strpos($Line['text'], '|'))
1028 |         {
1029 |             $Elements = array();
1030 | 
1031 |             $row = $Line['text'];
1032 | 
1033 |             $row = trim($row);
1034 |             $row = trim($row, '|');
1035 | 
1036 |             preg_match_all('/(?:(\\\\[|])|[^|`]|`[^`]++`|`)++/', $row, $matches);
1037 | 
1038 |             $cells = array_slice($matches[0], 0, count($Block['alignments']));
1039 | 
1040 |             foreach ($cells as $index => $cell)
1041 |             {
1042 |                 $cell = trim($cell);
1043 | 
1044 |                 $Element = array(
1045 |                     'name' => 'td',
1046 |                     'handler' => array(
1047 |                         'function' => 'lineElements',
1048 |                         'argument' => $cell,
1049 |                         'destination' => 'elements',
1050 |                     )
1051 |                 );
1052 | 
1053 |                 if (isset($Block['alignments'][$index]))
1054 |                 {
1055 |                     $Element['attributes'] = array(
1056 |                         'style' => 'text-align: ' . $Block['alignments'][$index] . ';',
1057 |                     );
1058 |                 }
1059 | 
1060 |                 $Elements []= $Element;
1061 |             }
1062 | 
1063 |             $Element = array(
1064 |                 'name' => 'tr',
1065 |                 'elements' => $Elements,
1066 |             );
1067 | 
1068 |             $Block['element']['elements'][1]['elements'] []= $Element;
1069 | 
1070 |             return $Block;
1071 |         }
1072 |     }
1073 | 
1074 |     #
1075 |     # ~
1076 |     #
1077 | 
1078 |     protected function paragraph($Line)
1079 |     {
1080 |         return array(
1081 |             'type' => 'Paragraph',
1082 |             'element' => array(
1083 |                 'name' => 'p',
1084 |                 'handler' => array(
1085 |                     'function' => 'lineElements',
1086 |                     'argument' => $Line['text'],
1087 |                     'destination' => 'elements',
1088 |                 ),
1089 |             ),
1090 |         );
1091 |     }
1092 | 
1093 |     protected function paragraphContinue($Line, array $Block)
1094 |     {
1095 |         if (isset($Block['interrupted']))
1096 |         {
1097 |             return;
1098 |         }
1099 | 
1100 |         $Block['element']['handler']['argument'] .= "\n".$Line['text'];
1101 | 
1102 |         return $Block;
1103 |     }
1104 | 
1105 |     #
1106 |     # Inline Elements
1107 |     #
1108 | 
1109 |     protected $InlineTypes = array(
1110 |         '!' => array('Image'),
1111 |         '&' => array('SpecialCharacter'),
1112 |         '*' => array('Emphasis'),
1113 |         ':' => array('Url'),
1114 |         '<' => array('UrlTag', 'EmailTag', 'Markup'),
1115 |         '[' => array('Link'),
1116 |         '_' => array('Emphasis'),
1117 |         '`' => array('Code'),
1118 |         '~' => array('Strikethrough'),
1119 |         '\\' => array('EscapeSequence'),
1120 |     );
1121 | 
1122 |     # ~
1123 | 
1124 |     protected $inlineMarkerList = '!*_&[:<`~\\';
1125 | 
1126 |     #
1127 |     # ~
1128 |     #
1129 | 
1130 |     public function line($text, $nonNestables = array())
1131 |     {
1132 |         return $this->elements($this->lineElements($text, $nonNestables));
1133 |     }
1134 | 
1135 |     protected function lineElements($text, $nonNestables = array())
1136 |     {
1137 |         # standardize line breaks
1138 |         $text = str_replace(array("\r\n", "\r"), "\n", $text);
1139 | 
1140 |         $Elements = array();
1141 | 
1142 |         $nonNestables = (empty($nonNestables)
1143 |             ? array()
1144 |             : array_combine($nonNestables, $nonNestables)
1145 |         );
1146 | 
1147 |         # $excerpt is based on the first occurrence of a marker
1148 | 
1149 |         while ($excerpt = strpbrk($text, $this->inlineMarkerList))
1150 |         {
1151 |             $marker = $excerpt[0];
1152 | 
1153 |             $markerPosition = strlen($text) - strlen($excerpt);
1154 | 
1155 |             $Excerpt = array('text' => $excerpt, 'context' => $text);
1156 | 
1157 |             foreach ($this->InlineTypes[$marker] as $inlineType)
1158 |             {
1159 |                 # check to see if the current inline type is nestable in the current context
1160 | 
1161 |                 if (isset($nonNestables[$inlineType]))
1162 |                 {
1163 |                     continue;
1164 |                 }
1165 | 
1166 |                 $Inline = $this->{"inline$inlineType"}($Excerpt);
1167 | 
1168 |                 if ( ! isset($Inline))
1169 |                 {
1170 |                     continue;
1171 |                 }
1172 | 
1173 |                 # makes sure that the inline belongs to "our" marker
1174 | 
1175 |                 if (isset($Inline['position']) and $Inline['position'] > $markerPosition)
1176 |                 {
1177 |                     continue;
1178 |                 }
1179 | 
1180 |                 # sets a default inline position
1181 | 
1182 |                 if ( ! isset($Inline['position']))
1183 |                 {
1184 |                     $Inline['position'] = $markerPosition;
1185 |                 }
1186 | 
1187 |                 # cause the new element to 'inherit' our non nestables
1188 | 
1189 | 
1190 |                 $Inline['element']['nonNestables'] = isset($Inline['element']['nonNestables'])
1191 |                     ? array_merge($Inline['element']['nonNestables'], $nonNestables)
1192 |                     : $nonNestables
1193 |                 ;
1194 | 
1195 |                 # the text that comes before the inline
1196 |                 $unmarkedText = substr($text, 0, $Inline['position']);
1197 | 
1198 |                 # compile the unmarked text
1199 |                 $InlineText = $this->inlineText($unmarkedText);
1200 |                 $Elements[] = $InlineText['element'];
1201 | 
1202 |                 # compile the inline
1203 |                 $Elements[] = $this->extractElement($Inline);
1204 | 
1205 |                 # remove the examined text
1206 |                 $text = substr($text, $Inline['position'] + $Inline['extent']);
1207 | 
1208 |                 continue 2;
1209 |             }
1210 | 
1211 |             # the marker does not belong to an inline
1212 | 
1213 |             $unmarkedText = substr($text, 0, $markerPosition + 1);
1214 | 
1215 |             $InlineText = $this->inlineText($unmarkedText);
1216 |             $Elements[] = $InlineText['element'];
1217 | 
1218 |             $text = substr($text, $markerPosition + 1);
1219 |         }
1220 | 
1221 |         $InlineText = $this->inlineText($text);
1222 |         $Elements[] = $InlineText['element'];
1223 | 
1224 |         foreach ($Elements as &$Element)
1225 |         {
1226 |             if ( ! isset($Element['autobreak']))
1227 |             {
1228 |                 $Element['autobreak'] = false;
1229 |             }
1230 |         }
1231 | 
1232 |         return $Elements;
1233 |     }
1234 | 
1235 |     #
1236 |     # ~
1237 |     #
1238 | 
1239 |     protected function inlineText($text)
1240 |     {
1241 |         $Inline = array(
1242 |             'extent' => strlen($text),
1243 |             'element' => array(),
1244 |         );
1245 | 
1246 |         $Inline['element']['elements'] = self::pregReplaceElements(
1247 |             $this->breaksEnabled ? '/[ ]*+\n/' : '/(?:[ ]*+\\\\|[ ]{2,}+)\n/',
1248 |             array(
1249 |                 array('name' => 'br'),
1250 |                 array('text' => "\n"),
1251 |             ),
1252 |             $text
1253 |         );
1254 | 
1255 |         return $Inline;
1256 |     }
1257 | 
1258 |     protected function inlineCode($Excerpt)
1259 |     {
1260 |         $marker = $Excerpt['text'][0];
1261 | 
1262 |         if (preg_match('/^(['.$marker.']++)[ ]*+(.+?)[ ]*+(?<!['.$marker.'])\1(?!'.$marker.')/s', $Excerpt['text'], $matches))
1263 |         {
1264 |             $text = $matches[2];
1265 |             $text = preg_replace('/[ ]*+\n/', ' ', $text);
1266 | 
1267 |             return array(
1268 |                 'extent' => strlen($matches[0]),
1269 |                 'element' => array(
1270 |                     'name' => 'code',
1271 |                     'text' => $text,
1272 |                 ),
1273 |             );
1274 |         }
1275 |     }
1276 | 
1277 |     protected function inlineEmailTag($Excerpt)
1278 |     {
1279 |         $hostnameLabel = '[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?';
1280 | 
1281 |         $commonMarkEmail = '[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]++@'
1282 |             . $hostnameLabel . '(?:\.' . $hostnameLabel . ')*';
1283 | 
1284 |         if (strpos($Excerpt['text'], '>') !== false
1285 |             and preg_match("/^<((mailto:)?$commonMarkEmail)>/i", $Excerpt['text'], $matches)
1286 |         ){
1287 |             $url = $matches[1];
1288 | 
1289 |             if ( ! isset($matches[2]))
1290 |             {
1291 |                 $url = "mailto:$url";
1292 |             }
1293 | 
1294 |             return array(
1295 |                 'extent' => strlen($matches[0]),
1296 |                 'element' => array(
1297 |                     'name' => 'a',
1298 |                     'text' => $matches[1],
1299 |                     'attributes' => array(
1300 |                         'href' => $url,
1301 |                     ),
1302 |                 ),
1303 |             );
1304 |         }
1305 |     }
1306 | 
1307 |     protected function inlineEmphasis($Excerpt)
1308 |     {
1309 |         if ( ! isset($Excerpt['text'][1]))
1310 |         {
1311 |             return;
1312 |         }
1313 | 
1314 |         $marker = $Excerpt['text'][0];
1315 | 
1316 |         if ($Excerpt['text'][1] === $marker and preg_match($this->StrongRegex[$marker], $Excerpt['text'], $matches))
1317 |         {
1318 |             $emphasis = 'strong';
1319 |         }
1320 |         elseif (preg_match($this->EmRegex[$marker], $Excerpt['text'], $matches))
1321 |         {
1322 |             $emphasis = 'em';
1323 |         }
1324 |         else
1325 |         {
1326 |             return;
1327 |         }
1328 | 
1329 |         return array(
1330 |             'extent' => strlen($matches[0]),
1331 |             'element' => array(
1332 |                 'name' => $emphasis,
1333 |                 'handler' => array(
1334 |                     'function' => 'lineElements',
1335 |                     'argument' => $matches[1],
1336 |                     'destination' => 'elements',
1337 |                 )
1338 |             ),
1339 |         );
1340 |     }
1341 | 
1342 |     protected function inlineEscapeSequence($Excerpt)
1343 |     {
1344 |         if (isset($Excerpt['text'][1]) and in_array($Excerpt['text'][1], $this->specialCharacters))
1345 |         {
1346 |             return array(
1347 |                 'element' => array('rawHtml' => $Excerpt['text'][1]),
1348 |                 'extent' => 2,
1349 |             );
1350 |         }
1351 |     }
1352 | 
1353 |     protected function inlineImage($Excerpt)
1354 |     {
1355 |         if ( ! isset($Excerpt['text'][1]) or $Excerpt['text'][1] !== '[')
1356 |         {
1357 |             return;
1358 |         }
1359 | 
1360 |         $Excerpt['text']= substr($Excerpt['text'], 1);
1361 | 
1362 |         $Link = $this->inlineLink($Excerpt);
1363 | 
1364 |         if ($Link === null)
1365 |         {
1366 |             return;
1367 |         }
1368 | 
1369 |         $Inline = array(
1370 |             'extent' => $Link['extent'] + 1,
1371 |             'element' => array(
1372 |                 'name' => 'img',
1373 |                 'attributes' => array(
1374 |                     'src' => $Link['element']['attributes']['href'],
1375 |                     'alt' => $Link['element']['handler']['argument'],
1376 |                 ),
1377 |                 'autobreak' => true,
1378 |             ),
1379 |         );
1380 | 
1381 |         $Inline['element']['attributes'] += $Link['element']['attributes'];
1382 | 
1383 |         unset($Inline['element']['attributes']['href']);
1384 | 
1385 |         return $Inline;
1386 |     }
1387 | 
1388 |     protected function inlineLink($Excerpt)
1389 |     {
1390 |         $Element = array(
1391 |             'name' => 'a',
1392 |             'handler' => array(
1393 |                 'function' => 'lineElements',
1394 |                 'argument' => null,
1395 |                 'destination' => 'elements',
1396 |             ),
1397 |             'nonNestables' => array('Url', 'Link'),
1398 |             'attributes' => array(
1399 |                 'href' => null,
1400 |                 'title' => null,
1401 |             ),
1402 |         );
1403 | 
1404 |         $extent = 0;
1405 | 
1406 |         $remainder = $Excerpt['text'];
1407 | 
1408 |         if (preg_match('/\[((?:[^][]++|(?R))*+)\]/', $remainder, $matches))
1409 |         {
1410 |             $Element['handler']['argument'] = $matches[1];
1411 | 
1412 |             $extent += strlen($matches[0]);
1413 | 
1414 |             $remainder = substr($remainder, $extent);
1415 |         }
1416 |         else
1417 |         {
1418 |             return;
1419 |         }
1420 | 
1421 |         if (preg_match('/^[(]\s*+((?:[^ ()]++|[(][^ )]+[)])++)(?:[ ]+("[^"]*+"|\'[^\']*+\'))?\s*+[)]/', $remainder, $matches))
1422 |         {
1423 |             $Element['attributes']['href'] = $matches[1];
1424 | 
1425 |             if (isset($matches[2]))
1426 |             {
1427 |                 $Element['attributes']['title'] = substr($matches[2], 1, - 1);
1428 |             }
1429 | 
1430 |             $extent += strlen($matches[0]);
1431 |         }
1432 |         else
1433 |         {
1434 |             if (preg_match('/^\s*\[(.*?)\]/', $remainder, $matches))
1435 |             {
1436 |                 $definition = strlen($matches[1]) ? $matches[1] : $Element['handler']['argument'];
1437 |                 $definition = strtolower($definition);
1438 | 
1439 |                 $extent += strlen($matches[0]);
1440 |             }
1441 |             else
1442 |             {
1443 |                 $definition = strtolower($Element['handler']['argument']);
1444 |             }
1445 | 
1446 |             if ( ! isset($this->DefinitionData['Reference'][$definition]))
1447 |             {
1448 |                 return;
1449 |             }
1450 | 
1451 |             $Definition = $this->DefinitionData['Reference'][$definition];
1452 | 
1453 |             $Element['attributes']['href'] = $Definition['url'];
1454 |             $Element['attributes']['title'] = $Definition['title'];
1455 |         }
1456 | 
1457 |         return array(
1458 |             'extent' => $extent,
1459 |             'element' => $Element,
1460 |         );
1461 |     }
1462 | 
1463 |     protected function inlineMarkup($Excerpt)
1464 |     {
1465 |         if ($this->markupEscaped or $this->safeMode or strpos($Excerpt['text'], '>') === false)
1466 |         {
1467 |             return;
1468 |         }
1469 | 
1470 |         if ($Excerpt['text'][1] === '/' and preg_match('/^<\/\w[\w-]*+[ ]*+>/s', $Excerpt['text'], $matches))
1471 |         {
1472 |             return array(
1473 |                 'element' => array('rawHtml' => $matches[0]),
1474 |                 'extent' => strlen($matches[0]),
1475 |             );
1476 |         }
1477 | 
1478 |         if ($Excerpt['text'][1] === '!' and preg_match('/^<!---?[^>-](?:-?+[^-])*-->/s', $Excerpt['text'], $matches))
1479 |         {
1480 |             return array(
1481 |                 'element' => array('rawHtml' => $matches[0]),
1482 |                 'extent' => strlen($matches[0]),
1483 |             );
1484 |         }
1485 | 
1486 |         if ($Excerpt['text'][1] !== ' ' and preg_match('/^<\w[\w-]*+(?:[ ]*+'.$this->regexHtmlAttribute.')*+[ ]*+\/?>/s', $Excerpt['text'], $matches))
1487 |         {
1488 |             return array(
1489 |                 'element' => array('rawHtml' => $matches[0]),
1490 |                 'extent' => strlen($matches[0]),
1491 |             );
1492 |         }
1493 |     }
1494 | 
1495 |     protected function inlineSpecialCharacter($Excerpt)
1496 |     {
1497 |         if (substr($Excerpt['text'], 1, 1) !== ' ' and strpos($Excerpt['text'], ';') !== false
1498 |             and preg_match('/^&(#?+[0-9a-zA-Z]++);/', $Excerpt['text'], $matches)
1499 |         ) {
1500 |             return array(
1501 |                 'element' => array('rawHtml' => '&' . $matches[1] . ';'),
1502 |                 'extent' => strlen($matches[0]),
1503 |             );
1504 |         }
1505 | 
1506 |         return;
1507 |     }
1508 | 
1509 |     protected function inlineStrikethrough($Excerpt)
1510 |     {
1511 |         if ( ! isset($Excerpt['text'][1]))
1512 |         {
1513 |             return;
1514 |         }
1515 | 
1516 |         if ($Excerpt['text'][1] === '~' and preg_match('/^~~(?=\S)(.+?)(?<=\S)~~/', $Excerpt['text'], $matches))
1517 |         {
1518 |             return array(
1519 |                 'extent' => strlen($matches[0]),
1520 |                 'element' => array(
1521 |                     'name' => 'del',
1522 |                     'handler' => array(
1523 |                         'function' => 'lineElements',
1524 |                         'argument' => $matches[1],
1525 |                         'destination' => 'elements',
1526 |                     )
1527 |                 ),
1528 |             );
1529 |         }
1530 |     }
1531 | 
1532 |     protected function inlineUrl($Excerpt)
1533 |     {
1534 |         if ($this->urlsLinked !== true or ! isset($Excerpt['text'][2]) or $Excerpt['text'][2] !== '/')
1535 |         {
1536 |             return;
1537 |         }
1538 | 
1539 |         if (strpos($Excerpt['context'], 'http') !== false
1540 |             and preg_match('/\bhttps?+:[\/]{2}[^\s<]+\b\/*+/ui', $Excerpt['context'], $matches, PREG_OFFSET_CAPTURE)
1541 |         ) {
1542 |             $url = $matches[0][0];
1543 | 
1544 |             $Inline = array(
1545 |                 'extent' => strlen($matches[0][0]),
1546 |                 'position' => $matches[0][1],
1547 |                 'element' => array(
1548 |                     'name' => 'a',
1549 |                     'text' => $url,
1550 |                     'attributes' => array(
1551 |                         'href' => $url,
1552 |                     ),
1553 |                 ),
1554 |             );
1555 | 
1556 |             return $Inline;
1557 |         }
1558 |     }
1559 | 
1560 |     protected function inlineUrlTag($Excerpt)
1561 |     {
1562 |         if (strpos($Excerpt['text'], '>') !== false and preg_match('/^<(\w++:\/{2}[^ >]++)>/i', $Excerpt['text'], $matches))
1563 |         {
1564 |             $url = $matches[1];
1565 | 
1566 |             return array(
1567 |                 'extent' => strlen($matches[0]),
1568 |                 'element' => array(
1569 |                     'name' => 'a',
1570 |                     'text' => $url,
1571 |                     'attributes' => array(
1572 |                         'href' => $url,
1573 |                     ),
1574 |                 ),
1575 |             );
1576 |         }
1577 |     }
1578 | 
1579 |     # ~
1580 | 
1581 |     protected function unmarkedText($text)
1582 |     {
1583 |         $Inline = $this->inlineText($text);
1584 |         return $this->element($Inline['element']);
1585 |     }
1586 | 
1587 |     #
1588 |     # Handlers
1589 |     #
1590 | 
1591 |     protected function handle(array $Element)
1592 |     {
1593 |         if (isset($Element['handler']))
1594 |         {
1595 |             if (!isset($Element['nonNestables']))
1596 |             {
1597 |                 $Element['nonNestables'] = array();
1598 |             }
1599 | 
1600 |             if (is_string($Element['handler']))
1601 |             {
1602 |                 $function = $Element['handler'];
1603 |                 $argument = $Element['text'];
1604 |                 unset($Element['text']);
1605 |                 $destination = 'rawHtml';
1606 |             }
1607 |             else
1608 |             {
1609 |                 $function = $Element['handler']['function'];
1610 |                 $argument = $Element['handler']['argument'];
1611 |                 $destination = $Element['handler']['destination'];
1612 |             }
1613 | 
1614 |             $Element[$destination] = $this->{$function}($argument, $Element['nonNestables']);
1615 | 
1616 |             if ($destination === 'handler')
1617 |             {
1618 |                 $Element = $this->handle($Element);
1619 |             }
1620 | 
1621 |             unset($Element['handler']);
1622 |         }
1623 | 
1624 |         return $Element;
1625 |     }
1626 | 
1627 |     protected function handleElementRecursive(array $Element)
1628 |     {
1629 |         return $this->elementApplyRecursive(array($this, 'handle'), $Element);
1630 |     }
1631 | 
1632 |     protected function handleElementsRecursive(array $Elements)
1633 |     {
1634 |         return $this->elementsApplyRecursive(array($this, 'handle'), $Elements);
1635 |     }
1636 | 
1637 |     protected function elementApplyRecursive($closure, array $Element)
1638 |     {
1639 |         $Element = call_user_func($closure, $Element);
1640 | 
1641 |         if (isset($Element['elements']))
1642 |         {
1643 |             $Element['elements'] = $this->elementsApplyRecursive($closure, $Element['elements']);
1644 |         }
1645 |         elseif (isset($Element['element']))
1646 |         {
1647 |             $Element['element'] = $this->elementApplyRecursive($closure, $Element['element']);
1648 |         }
1649 | 
1650 |         return $Element;
1651 |     }
1652 | 
1653 |     protected function elementApplyRecursiveDepthFirst($closure, array $Element)
1654 |     {
1655 |         if (isset($Element['elements']))
1656 |         {
1657 |             $Element['elements'] = $this->elementsApplyRecursiveDepthFirst($closure, $Element['elements']);
1658 |         }
1659 |         elseif (isset($Element['element']))
1660 |         {
1661 |             $Element['element'] = $this->elementsApplyRecursiveDepthFirst($closure, $Element['element']);
1662 |         }
1663 | 
1664 |         $Element = call_user_func($closure, $Element);
1665 | 
1666 |         return $Element;
1667 |     }
1668 | 
1669 |     protected function elementsApplyRecursive($closure, array $Elements)
1670 |     {
1671 |         foreach ($Elements as &$Element)
1672 |         {
1673 |             $Element = $this->elementApplyRecursive($closure, $Element);
1674 |         }
1675 | 
1676 |         return $Elements;
1677 |     }
1678 | 
1679 |     protected function elementsApplyRecursiveDepthFirst($closure, array $Elements)
1680 |     {
1681 |         foreach ($Elements as &$Element)
1682 |         {
1683 |             $Element = $this->elementApplyRecursiveDepthFirst($closure, $Element);
1684 |         }
1685 | 
1686 |         return $Elements;
1687 |     }
1688 | 
1689 |     protected function element(array $Element)
1690 |     {
1691 |         if ($this->safeMode)
1692 |         {
1693 |             $Element = $this->sanitiseElement($Element);
1694 |         }
1695 | 
1696 |         # identity map if element has no handler
1697 |         $Element = $this->handle($Element);
1698 | 
1699 |         $hasName = isset($Element['name']);
1700 | 
1701 |         $markup = '';
1702 | 
1703 |         if ($hasName)
1704 |         {
1705 |             $markup .= '<' . $Element['name'];
1706 | 
1707 |             if (isset($Element['attributes']))
1708 |             {
1709 |                 foreach ($Element['attributes'] as $name => $value)
1710 |                 {
1711 |                     if ($value === null)
1712 |                     {
1713 |                         continue;
1714 |                     }
1715 | 
1716 |                     $markup .= " $name=\"".self::escape($value).'"';
1717 |                 }
1718 |             }
1719 |         }
1720 | 
1721 |         $permitRawHtml = false;
1722 | 
1723 |         if (isset($Element['text']))
1724 |         {
1725 |             $text = $Element['text'];
1726 |         }
1727 |         // very strongly consider an alternative if you're writing an
1728 |         // extension
1729 |         elseif (isset($Element['rawHtml']))
1730 |         {
1731 |             $text = $Element['rawHtml'];
1732 | 
1733 |             $allowRawHtmlInSafeMode = isset($Element['allowRawHtmlInSafeMode']) && $Element['allowRawHtmlInSafeMode'];
1734 |             $permitRawHtml = !$this->safeMode || $allowRawHtmlInSafeMode;
1735 |         }
1736 | 
1737 |         $hasContent = isset($text) || isset($Element['element']) || isset($Element['elements']);
1738 | 
1739 |         if ($hasContent)
1740 |         {
1741 |             $markup .= $hasName ? '>' : '';
1742 | 
1743 |             if (isset($Element['elements']))
1744 |             {
1745 |                 $markup .= $this->elements($Element['elements']);
1746 |             }
1747 |             elseif (isset($Element['element']))
1748 |             {
1749 |                 $markup .= $this->element($Element['element']);
1750 |             }
1751 |             else
1752 |             {
1753 |                 if (!$permitRawHtml)
1754 |                 {
1755 |                     $markup .= self::escape($text, true);
1756 |                 }
1757 |                 else
1758 |                 {
1759 |                     $markup .= $text;
1760 |                 }
1761 |             }
1762 | 
1763 |             $markup .= $hasName ? '</' . $Element['name'] . '>' : '';
1764 |         }
1765 |         elseif ($hasName)
1766 |         {
1767 |             $markup .= ' />';
1768 |         }
1769 | 
1770 |         return $markup;
1771 |     }
1772 | 
1773 |     protected function elements(array $Elements)
1774 |     {
1775 |         $markup = '';
1776 | 
1777 |         $autoBreak = true;
1778 | 
1779 |         foreach ($Elements as $Element)
1780 |         {
1781 |             if (empty($Element))
1782 |             {
1783 |                 continue;
1784 |             }
1785 | 
1786 |             $autoBreakNext = (isset($Element['autobreak'])
1787 |                 ? $Element['autobreak'] : isset($Element['name'])
1788 |             );
1789 |             // (autobreak === false) covers both sides of an element
1790 |             $autoBreak = !$autoBreak ? $autoBreak : $autoBreakNext;
1791 | 
1792 |             $markup .= ($autoBreak ? "\n" : '') . $this->element($Element);
1793 |             $autoBreak = $autoBreakNext;
1794 |         }
1795 | 
1796 |         $markup .= $autoBreak ? "\n" : '';
1797 | 
1798 |         return $markup;
1799 |     }
1800 | 
1801 |     # ~
1802 | 
1803 |     protected function li($lines)
1804 |     {
1805 |         $Elements = $this->linesElements($lines);
1806 | 
1807 |         if ( ! in_array('', $lines)
1808 |             and isset($Elements[0]) and isset($Elements[0]['name'])
1809 |             and $Elements[0]['name'] === 'p'
1810 |         ) {
1811 |             unset($Elements[0]['name']);
1812 |         }
1813 | 
1814 |         return $Elements;
1815 |     }
1816 | 
1817 |     #
1818 |     # AST Convenience
1819 |     #
1820 | 
1821 |     /**
1822 |      * Replace occurrences $regexp with $Elements in $text. Return an array of
1823 |      * elements representing the replacement.
1824 |      */
1825 |     protected static function pregReplaceElements($regexp, $Elements, $text)
1826 |     {
1827 |         $newElements = array();
1828 | 
1829 |         while (preg_match($regexp, $text, $matches, PREG_OFFSET_CAPTURE))
1830 |         {
1831 |             $offset = $matches[0][1];
1832 |             $before = substr($text, 0, $offset);
1833 |             $after = substr($text, $offset + strlen($matches[0][0]));
1834 | 
1835 |             $newElements[] = array('text' => $before);
1836 | 
1837 |             foreach ($Elements as $Element)
1838 |             {
1839 |                 $newElements[] = $Element;
1840 |             }
1841 | 
1842 |             $text = $after;
1843 |         }
1844 | 
1845 |         $newElements[] = array('text' => $text);
1846 | 
1847 |         return $newElements;
1848 |     }
1849 | 
1850 |     #
1851 |     # Deprecated Methods
1852 |     #
1853 | 
1854 |     function parse($text)
1855 |     {
1856 |         $markup = $this->text($text);
1857 | 
1858 |         return $markup;
1859 |     }
1860 | 
1861 |     protected function sanitiseElement(array $Element)
1862 |     {
1863 |         static $goodAttribute = '/^[a-zA-Z0-9][a-zA-Z0-9-_]*+$/';
1864 |         static $safeUrlNameToAtt  = array(
1865 |             'a'   => 'href',
1866 |             'img' => 'src',
1867 |         );
1868 | 
1869 |         if ( ! isset($Element['name']))
1870 |         {
1871 |             unset($Element['attributes']);
1872 |             return $Element;
1873 |         }
1874 | 
1875 |         if (isset($safeUrlNameToAtt[$Element['name']]))
1876 |         {
1877 |             $Element = $this->filterUnsafeUrlInAttribute($Element, $safeUrlNameToAtt[$Element['name']]);
1878 |         }
1879 | 
1880 |         if ( ! empty($Element['attributes']))
1881 |         {
1882 |             foreach ($Element['attributes'] as $att => $val)
1883 |             {
1884 |                 # filter out badly parsed attribute
1885 |                 if ( ! preg_match($goodAttribute, $att))
1886 |                 {
1887 |                     unset($Element['attributes'][$att]);
1888 |                 }
1889 |                 # dump onevent attribute
1890 |                 elseif (self::striAtStart($att, 'on'))
1891 |                 {
1892 |                     unset($Element['attributes'][$att]);
1893 |                 }
1894 |             }
1895 |         }
1896 | 
1897 |         return $Element;
1898 |     }
1899 | 
1900 |     protected function filterUnsafeUrlInAttribute(array $Element, $attribute)
1901 |     {
1902 |         foreach ($this->safeLinksWhitelist as $scheme)
1903 |         {
1904 |             if (self::striAtStart($Element['attributes'][$attribute], $scheme))
1905 |             {
1906 |                 return $Element;
1907 |             }
1908 |         }
1909 | 
1910 |         $Element['attributes'][$attribute] = str_replace(':', '%3A', $Element['attributes'][$attribute]);
1911 | 
1912 |         return $Element;
1913 |     }
1914 | 
1915 |     #
1916 |     # Static Methods
1917 |     #
1918 | 
1919 |     protected static function escape($text, $allowQuotes = false)
1920 |     {
1921 |         return htmlspecialchars($text, $allowQuotes ? ENT_NOQUOTES : ENT_QUOTES, 'UTF-8');
1922 |     }
1923 | 
1924 |     protected static function striAtStart($string, $needle)
1925 |     {
1926 |         $len = strlen($needle);
1927 | 
1928 |         if ($len > strlen($string))
1929 |         {
1930 |             return false;
1931 |         }
1932 |         else
1933 |         {
1934 |             return strtolower(substr($string, 0, $len)) === strtolower($needle);
1935 |         }
1936 |     }
1937 | 
1938 |     static function instance($name = 'default')
1939 |     {
1940 |         if (isset(self::$instances[$name]))
1941 |         {
1942 |             return self::$instances[$name];
1943 |         }
1944 | 
1945 |         $instance = new static();
1946 | 
1947 |         self::$instances[$name] = $instance;
1948 | 
1949 |         return $instance;
1950 |     }
1951 | 
1952 |     private static $instances = array();
1953 | 
1954 |     #
1955 |     # Fields
1956 |     #
1957 | 
1958 |     protected $DefinitionData;
1959 | 
1960 |     #
1961 |     # Read-Only
1962 | 
1963 |     protected $specialCharacters = array(
1964 |         '\\', '`', '*', '_', '{', '}', '[', ']', '(', ')', '>', '#', '+', '-', '.', '!', '|', '~'
1965 |     );
1966 | 
1967 |     protected $StrongRegex = array(
1968 |         '*' => '/^[*]{2}((?:\\\\\*|[^*]|[*][^*]*+[*])+?)[*]{2}(?![*])/s',
1969 |         '_' => '/^__((?:\\\\_|[^_]|_[^_]*+_)+?)__(?!_)/us',
1970 |     );
1971 | 
1972 |     protected $EmRegex = array(
1973 |         '*' => '/^[*]((?:\\\\\*|[^*]|[*][*][^*]+?[*][*])+?)[*](?![*])/s',
1974 |         '_' => '/^_((?:\\\\_|[^_]|__[^_]*__)+?)_(?!_)\b/us',
1975 |     );
1976 | 
1977 |     protected $regexHtmlAttribute = '[a-zA-Z_:][\w:.-]*+(?:\s*+=\s*+(?:[^"\'=<>`\s]+|"[^"]*+"|\'[^\']*+\'))?+';
1978 | 
1979 |     protected $voidElements = array(
1980 |         'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source',
1981 |     );
1982 | 
1983 |     protected $textLevelElements = array(
1984 |         'a', 'br', 'bdo', 'abbr', 'blink', 'nextid', 'acronym', 'basefont',
1985 |         'b', 'em', 'big', 'cite', 'small', 'spacer', 'listing',
1986 |         'i', 'rp', 'del', 'code',          'strike', 'marquee',
1987 |         'q', 'rt', 'ins', 'font',          'strong',
1988 |         's', 'tt', 'kbd', 'mark',
1989 |         'u', 'xm', 'sub', 'nobr',
1990 |                    'sup', 'ruby',
1991 |                    'var', 'span',
1992 |                    'wbr', 'time',
1993 |     );
1994 | }
1995 | 


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