First versionHEADmaster

1 files changed, 538 insertions, 0 deletions

diff --git a/point/libs/markdownjs/markdown.min.js b/point/libs/markdownjs/markdown.min.js
new file mode 100644
index 0000000..9bf8d3f
--- /dev/null
+++ b/point/libs/markdownjs/markdown.min.js
@@ -0,0 +1,538 @@
+!function (a) {
+        function b() {
+                return"Markdown.mk_block( " + uneval(this.toString()) + ", " + uneval(this.trailing) + ", " + uneval(this.lineNumber) + " )"
+        }
+
+        function c() {
+                var a = require("util");
+                return"Markdown.mk_block( " + a.inspect(this.toString()) + ", " + a.inspect(this.trailing) + ", " + a.inspect(this.lineNumber) + " )"
+        }
+
+        function d(a) {
+                for (var b = 0, c = -1; -1 !== (c = a.indexOf("\n", c + 1));)b++;
+                return b
+        }
+
+        function e(a) {
+                return a.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;")
+        }
+
+        function f(a) {
+                if ("string" == typeof a)return e(a);
+                var b = a.shift(), c = {}, d = [];
+                for (!a.length || "object" != typeof a[0] || a[0]instanceof Array || (c = a.shift()); a.length;)d.push(f(a.shift()));
+                var g = "";
+                for (var h in c)g += " " + h + '="' + e(c[h]) + '"';
+                return"img" === b || "br" === b || "hr" === b ? "<" + b + g + "/>" : "<" + b + g + ">" + d.join("") + "</" + b + ">"
+        }
+
+        function g(a, b, c) {
+                var d;
+                c = c || {};
+                var e = a.slice(0);
+                "function" == typeof c.preprocessTreeNode && (e = c.preprocessTreeNode(e, b));
+                var f = o(e);
+                if (f) {
+                        e[1] = {};
+                        for (d in f)e[1][d] = f[d];
+                        f = e[1]
+                }
+                if ("string" == typeof e)return e;
+                switch (e[0]) {
+                        case"header":
+                                e[0] = "h" + e[1].level, delete e[1].level;
+                                break;
+                        case"bulletlist":
+                                e[0] = "ul";
+                                break;
+                        case"numberlist":
+                                e[0] = "ol";
+                                break;
+                        case"listitem":
+                                e[0] = "li";
+                                break;
+                        case"para":
+                                e[0] = "p";
+                                break;
+                        case"markdown":
+                                e[0] = "html", f && delete f.references;
+                                break;
+                        case"code_block":
+                                e[0] = "pre", d = f ? 2 : 1;
+                                var h = ["code"];
+                                h.push.apply(h, e.splice(d, e.length - d)), e[d] = h;
+                                break;
+                        case"inlinecode":
+                                e[0] = "code";
+                                break;
+                        case"img":
+                                e[1].src = e[1].href, delete e[1].href;
+                                break;
+                        case"linebreak":
+                                e[0] = "br";
+                                break;
+                        case"link":
+                                e[0] = "a";
+                                break;
+                        case"link_ref":
+                                e[0] = "a";
+                                var i = b[f.ref];
+                                if (!i)return f.original;
+                                delete f.ref, f.href = i.href, i.title && (f.title = i.title), delete f.original;
+                                break;
+                        case"img_ref":
+                                e[0] = "img";
+                                var i = b[f.ref];
+                                if (!i)return f.original;
+                                delete f.ref, f.src = i.href, i.title && (f.title = i.title), delete f.original
+                }
+                if (d = 1, f) {
+                        for (var j in e[1]) {
+                                d = 2;
+                                break
+                        }
+                        1 === d && e.splice(d, 1)
+                }
+                for (; d < e.length; ++d)e[d] = g(e[d], b, c);
+                return e
+        }
+
+        function h(a) {
+                for (var b = o(a) ? 2 : 1; b < a.length;)"string" == typeof a[b] ? b + 1 < a.length && "string" == typeof a[b + 1] ? a[b] += a.splice(b + 1, 1)[0] : ++b : (h(a[b]), ++b)
+        }
+
+        function i(a, b) {
+                function c(a) {
+                        this.len_after = a, this.name = "close_" + b
+                }
+
+                var d = a + "_state", e = "strong" === a ? "em_state" : "strong_state";
+                return function (f) {
+                        if (this[d][0] === b)return this[d].shift(), [f.length, new c(f.length - b.length)];
+                        var g = this[e].slice(), h = this[d].slice();
+                        this[d].unshift(b);
+                        var i = this.processInline(f.substr(b.length)), j = i[i.length - 1];
+                        if (this[d].shift(), j instanceof c) {
+                                i.pop();
+                                var k = f.length - j.len_after;
+                                return[k, [a].concat(i)]
+                        }
+                        return this[e] = g, this[d] = h, [b.length, b]
+                }
+        }
+
+        function j(a) {
+                for (var b = a.split(""), c = [""], d = !1; b.length;) {
+                        var e = b.shift();
+                        switch (e) {
+                                case" ":
+                                        d ? c[c.length - 1] += e : c.push("");
+                                        break;
+                                case"'":
+                                case'"':
+                                        d = !d;
+                                        break;
+                                case"\\":
+                                        e = b.shift();
+                                default:
+                                        c[c.length - 1] += e
+                        }
+                }
+                return c
+        }
+
+        var k = {};
+        k.mk_block = function (a, d, e) {
+                1 === arguments.length && (d = "\n\n");
+                var f = new String(a);
+                return f.trailing = d, f.inspect = c, f.toSource = b, void 0 !== e && (f.lineNumber = e), f
+        };
+        var l = k.isArray = Array.isArray || function (a) {
+                return"[object Array]" === Object.prototype.toString.call(a)
+        };
+        k.forEach = Array.prototype.forEach ? function (a, b, c) {
+                return a.forEach(b, c)
+        } : function (a, b, c) {
+                for (var d = 0; d < a.length; d++)b.call(c || a, a[d], d, a)
+        }, k.isEmpty = function (a) {
+                for (var b in a)if (hasOwnProperty.call(a, b))return!1;
+                return!0
+        }, k.extract_attr = function (a) {
+                return l(a) && a.length > 1 && "object" == typeof a[1] && !l(a[1]) ? a[1] : void 0
+        };
+        var m = function (a) {
+                switch (typeof a) {
+                        case"undefined":
+                                this.dialect = m.dialects.Gruber;
+                                break;
+                        case"object":
+                                this.dialect = a;
+                                break;
+                        default:
+                                if (!(a in m.dialects))throw new Error("Unknown Markdown dialect '" + String(a) + "'");
+                                this.dialect = m.dialects[a]
+                }
+                this.em_state = [], this.strong_state = [], this.debug_indent = ""
+        };
+        m.dialects = {};
+        var n = m.mk_block = k.mk_block, l = k.isArray;
+        m.parse = function (a, b) {
+                var c = new m(b);
+                return c.toTree(a)
+        }, m.prototype.split_blocks = function (a) {
+                a = a.replace(/(\r\n|\n|\r)/g, "\n");
+                var b, c = /([\s\S]+?)($|\n#|\n(?:\s*\n|$)+)/g, e = [], f = 1;
+                for (null !== (b = /^(\s*\n)/.exec(a)) && (f += d(b[0]), c.lastIndex = b[0].length); null !== (b = c.exec(a));)"\n#" === b[2] && (b[2] = "\n", c.lastIndex--), e.push(n(b[1], b[2], f)), f += d(b[0]);
+                return e
+        }, m.prototype.processBlock = function (a, b) {
+                var c = this.dialect.block, d = c.__order__;
+                if ("__call__"in c)return c.__call__.call(this, a, b);
+                for (var e = 0; e < d.length; e++) {
+                        var f = c[d[e]].call(this, a, b);
+                        if (f)return(!l(f) || f.length > 0 && !l(f[0])) && this.debug(d[e], "didn't return a proper array"), f
+                }
+                return[]
+        }, m.prototype.processInline = function (a) {
+                return this.dialect.inline.__call__.call(this, String(a))
+        }, m.prototype.toTree = function (a, b) {
+                var c = a instanceof Array ? a : this.split_blocks(a), d = this.tree;
+                try {
+                        for (this.tree = b || this.tree || ["markdown"]; c.length;) {
+                                var e = this.processBlock(c.shift(), c);
+                                e.length && this.tree.push.apply(this.tree, e)
+                        }
+                        return this.tree
+                } finally {
+                        b && (this.tree = d)
+                }
+        }, m.prototype.debug = function () {
+                var a = Array.prototype.slice.call(arguments);
+                a.unshift(this.debug_indent), "undefined" != typeof print && print.apply(print, a), "undefined" != typeof con