@honkit/markup-it 3.6.17 → 3.7.2

package/README.md

@@ -1,8 +1,8 @@
-# @honkite/markup-it
+# @honkit/markup-it
 
-`@honkite/markup-it` is a JavaScript library to parse and modify markuped content (for example Markdown) using an intermediate format backed by an immutable model.
+`@honkit/markup-it` is a JavaScript library to parse and modify markuped content (for example Markdown) using an intermediate format backed by an immutable model.
 
-`@honkite/markup-it` is fork of [markup-it](https://github.com/GitbookIO/markup-it)@2.2.0
+`@honkit/markup-it` is fork of [markup-it](https://github.com/GitbookIO/markup-it)@2.2.0
 
 - Less dependency
 - For stability
@@ -10,7 +10,7 @@
 ### Installation
 
 ```
-$ npm i @honkite/markup-it  --save
+$ npm i @honkit/markup-it  --save
 ```
 
 ### Usage
@@ -18,9 +18,9 @@ $ npm i @honkite/markup-it  --save
 Initialize a syntax:
 
 ```js
-var MarkupIt = require('@honkite/markup-it');
-var markdownSyntax = require('@honkite/markup-it/syntaxes/markdown');
-var htmlSyntax = require('@honkite/markup-it/syntaxes/html');
+var MarkupIt = require('@honkit/markup-it');
+var markdownSyntax = require('@honkit/markup-it/syntaxes/markdown');
+var htmlSyntax = require('@honkit/markup-it/syntaxes/html');
 
 var markdown = new MarkupIt(markdownSyntax);
 var html = new MarkupIt(htmlSyntax);

package/lib/__tests__/syntax.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const __1 = __importDefault(require(".."));
+describe("Custom Syntax", () => {
+    const syntax = __1.default.Syntax("mysyntax", {
+        inline: [
+            __1.default.Rule(__1.default.STYLES.BOLD)
+                .regExp(/^\*\*([\s\S]+?)\*\*/, (state, match) => {
+                return {
+                    text: match[1],
+                };
+            })
+                .toText("**%s**"),
+        ],
+    });
+    const markup = new __1.default(syntax);
+    describe(".toContent", () => {
+        it("should return correct syntax name", () => {
+            const content = markup.toContent("Hello");
+            content.getSyntax().should.equal("mysyntax");
+        });
+        it("should parse as unstyled", () => {
+            const content = markup.toContent("Hello World");
+            const doc = content.getToken();
+            const blocks = doc.getTokens();
+            blocks.size.should.equal(1);
+            const p = blocks.get(0);
+            p.getType().should.equal(__1.default.BLOCKS.TEXT);
+            p.getAsPlainText().should.equal("Hello World");
+        });
+        it("should parse inline", () => {
+            const content = markup.toContent("Hello **World**");
+            const doc = content.getToken();
+            const blocks = doc.getTokens();
+            blocks.size.should.equal(1);
+            const p = blocks.get(0);
+            p.getType().should.equal(__1.default.BLOCKS.TEXT);
+            p.getAsPlainText().should.equal("Hello World");
+        });
+    });
+    describe(".toText", () => {
+        it("should output correct string", () => {
+            const content = __1.default.JSONUtils.decode({
+                syntax: "mysyntax",
+                token: {
+                    type: __1.default.BLOCKS.DOCUMENT,
+                    tokens: [
+                        {
+                            type: __1.default.BLOCKS.PARAGRAPH,
+                            tokens: [
+                                {
+                                    type: __1.default.STYLES.TEXT,
+                                    text: "Hello ",
+                                },
+                                {
+                                    type: __1.default.STYLES.BOLD,
+                                    text: "World",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            });
+            const text = markup.toText(content);
+            text.should.equal("Hello **World**\n");
+        });
+    });
+});

package/lib/constants/defaultRules.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const rule_1 = __importDefault(require("../models/rule"));
 const blocks_1 = __importDefault(require("./blocks"));
 const styles_1 = __importDefault(require("./styles"));
-const defaultDocumentRule = rule_1.default(blocks_1.default.DOCUMENT)
+const defaultDocumentRule = (0, rule_1.default)(blocks_1.default.DOCUMENT)
     .match((state, text) => {
     return {
         tokens: state.parseAsBlock(text),
@@ -15,14 +15,14 @@ const defaultDocumentRule = rule_1.default(blocks_1.default.DOCUMENT)
     .toText((state, token) => {
     return state.renderAsBlock(token);
 });
-const defaultBlockRule = rule_1.default(blocks_1.default.TEXT)
+const defaultBlockRule = (0, rule_1.default)(blocks_1.default.TEXT)
     .match((state, text) => {
     return {
         tokens: state.parseAsInline(text),
     };
 })
     .toText("%s\n");
-const defaultInlineRule = rule_1.default(styles_1.default.TEXT)
+const defaultInlineRule = (0, rule_1.default)(styles_1.default.TEXT)
     .match((state, text) => {
     return {
         text: text,

package/lib/json/__tests__/decode.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const decode_1 = __importDefault(require("../decode"));
+const blocks_1 = __importDefault(require("../../constants/blocks"));
+describe("decode", () => {
+    let content;
+    beforeAll(() => {
+        content = (0, decode_1.default)({
+            syntax: "mysyntax",
+            token: {
+                type: blocks_1.default.DOCUMENT,
+                tokens: [
+                    {
+                        type: blocks_1.default.PARAGRAPH,
+                        text: "Hello World",
+                        raw: "Hello World",
+                    },
+                ],
+            },
+        });
+    });
+    it("should decode syntax name", () => {
+        content.getSyntax().should.equal("mysyntax");
+    });
+    it("should decode tokens tree", () => {
+        const doc = content.getToken();
+        const tokens = doc.getTokens();
+        tokens.size.should.equal(1);
+        const p = tokens.get(0);
+        p.getType().should.equal(blocks_1.default.PARAGRAPH);
+        p.getText().should.equal("Hello World");
+        p.getRaw().should.equal("Hello World");
+        p.getTokens().size.should.equal(0);
+    });
+});

package/lib/json/__tests__/encode.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const encode_1 = __importDefault(require("../encode"));
+const blocks_1 = __importDefault(require("../../constants/blocks"));
+describe("encode", () => {
+    let json;
+    beforeAll(() => {
+        // @ts-expect-error
+        json = (0, encode_1.default)(mock.paragraph);
+    });
+    it("should encode syntax name", () => {
+        json.syntax.should.equal("mysyntax");
+    });
+    it("should encode tokens", () => {
+        json.should.have.property("token");
+        const doc = json.token;
+        doc.tokens.should.have.lengthOf(1);
+        const p = doc.tokens[0];
+        p.type.should.equal(blocks_1.default.PARAGRAPH);
+        p.text.should.equal("Hello World");
+        p.tokens.should.be.an.Array().with.lengthOf(2);
+    });
+});

package/lib/markup.js

@@ -22,7 +22,7 @@ function DraftMarkup(syntax) {
  * @return {ContentState}
  */
 DraftMarkup.prototype.toContent = function toContent(text, options) {
-    return parse_1.default(this.syntax, text, options);
+    return (0, parse_1.default)(this.syntax, text, options);
 };
 /**
  * Convert a text into an inline parsed content
@@ -40,7 +40,7 @@ DraftMarkup.prototype.toInlineContent = function toInlineContent(text) {
  * @return {string}
  */
 DraftMarkup.prototype.toText = function toText(content, options) {
-    return render_1.default(this.syntax, content, options);
+    return (0, render_1.default)(this.syntax, content, options);
 };
 /**
  * Convert a content to text

package/lib/models/__tests__/token.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const token_1 = __importDefault(require("../token"));
+const styles_1 = __importDefault(require("../../constants/styles"));
+describe("Token", () => {
+    describe(".mergeWith", () => {
+        it("should merge text and raw", () => {
+            const base = token_1.default.createText("Hello ");
+            const other = token_1.default.createText("world");
+            const token = base.mergeWith(other);
+            token.getType().should.equal(styles_1.default.TEXT);
+            token.getText().should.equal("Hello world");
+        });
+    });
+});

package/lib/models/token.js

@@ -57,7 +57,7 @@ Token.prototype.getTokens = function () {
  * @return {boolean}
  */
 Token.prototype.isBlock = function () {
-    return isBlock_1.default(this);
+    return (0, isBlock_1.default)(this);
 };
 /**
  * Return true if is an inline token
@@ -71,14 +71,14 @@ Token.prototype.isInline = function () {
  * @return {boolean}
  */
 Token.prototype.isStyle = function () {
-    return isStyle_1.default(this);
+    return (0, isStyle_1.default)(this);
 };
 /**
  * Return true if is an inline entity
  * @return {boolean}
  */
 Token.prototype.isEntity = function () {
-    return isEntity_1.default(this);
+    return (0, isEntity_1.default)(this);
 };
 /**
  * Merge this token with another one

package/lib/parse/__tests__/mergeTokens.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const token_1 = __importDefault(require("../../models/token"));
+const styles_1 = __importDefault(require("../../constants/styles"));
+const mergeTokens_1 = __importDefault(require("../mergeTokens"));
+describe("mergeTokens", () => {
+    it("should merge two tokens", () => {
+        const tokens = immutable_1.default.List([token_1.default.createText("Hello "), token_1.default.createText("world")]);
+        const merged = (0, mergeTokens_1.default)(tokens, [styles_1.default.TEXT]);
+        merged.size.should.equal(1);
+        const resultToken = merged.get(0);
+        resultToken.getType().should.equal(styles_1.default.TEXT);
+        resultToken.getText().should.equal("Hello world");
+    });
+    it("should merge three tokens", () => {
+        const tokens = immutable_1.default.List([token_1.default.createText("Hello "), token_1.default.createText("world"), token_1.default.createText("!")]);
+        const merged = (0, mergeTokens_1.default)(tokens, [styles_1.default.TEXT]);
+        merged.size.should.equal(1);
+        const resultToken = merged.get(0);
+        resultToken.getType().should.equal(styles_1.default.TEXT);
+        resultToken.getText().should.equal("Hello world!");
+    });
+    it("should merge 2x2 tokens", () => {
+        const tokens = immutable_1.default.List([
+            token_1.default.createText("Hello "),
+            token_1.default.createText("world"),
+            // @ts-ignore
+            new token_1.default({
+                type: styles_1.default.BOLD,
+                text: ", right?",
+            }),
+            token_1.default.createText("!"),
+            token_1.default.createText("!"),
+        ]);
+        const merged = (0, mergeTokens_1.default)(tokens, [styles_1.default.TEXT]);
+        merged.size.should.equal(3);
+        const first = merged.get(0);
+        const bold = merged.get(1);
+        const second = merged.get(2);
+        first.getType().should.equal(styles_1.default.TEXT);
+        first.getText().should.equal("Hello world");
+        bold.getType().should.equal(styles_1.default.BOLD);
+        bold.getText().should.equal(", right?");
+        second.getType().should.equal(styles_1.default.TEXT);
+        second.getText().should.equal("!!");
+    });
+});

package/lib/parse/index.js

@@ -16,7 +16,7 @@ function parse(syntax, text, options) {
     const entryRule = syntax.getEntryRule();
     // @ts-ignore
     const state = new state_1.default(syntax, options);
-    const tokens = matchRule_1.default(state, entryRule, text);
+    const tokens = (0, matchRule_1.default)(state, entryRule, text);
     return content_1.default.createFromToken(syntax.getName(), tokens.first());
 }
 /**

package/lib/parse/lex.js

@@ -21,10 +21,10 @@ function lex(state, rules, isInline, text, nonParsed) {
     let matchedTokens;
     nonParsed = nonParsed || "";
     if (!text) {
-        return tokens.concat(textToUnstyledTokens_1.default(state, isInline, nonParsed));
+        return tokens.concat((0, textToUnstyledTokens_1.default)(state, isInline, nonParsed));
     }
     rules.forEach((rule) => {
-        matchedTokens = matchRule_1.default(state, rule, text);
+        matchedTokens = (0, matchRule_1.default)(state, rule, text);
         if (!matchedTokens) {
             return;
         }
@@ -39,7 +39,7 @@ function lex(state, rules, isInline, text, nonParsed) {
         return result.substring(token.getRaw().length);
     }, text);
     // Keep parsing
-    tokens = textToUnstyledTokens_1.default(state, isInline, nonParsed)
+    tokens = (0, textToUnstyledTokens_1.default)(state, isInline, nonParsed)
         .concat(matchedTokens)
         // @ts-ignore
         .concat(lex(state, rules, isInline, newText));

package/lib/parse/state.js

@@ -85,9 +85,9 @@ ParsingState.prototype.parse = function (rulesSet, isInline, text) {
     this.depth++;
     const rules = rulesSet.getRules();
     // @ts-ignore
-    let tokens = lex_1.default(this, rules, isInline, text);
+    let tokens = (0, lex_1.default)(this, rules, isInline, text);
     if (isInline) {
-        tokens = mergeTokens_1.default(tokens, [styles_1.default.TEXT]);
+        tokens = (0, mergeTokens_1.default)(tokens, [styles_1.default.TEXT]);
     }
     this.depth--;
     return tokens;

package/lib/parse/textToUnstyledTokens.js

@@ -16,7 +16,7 @@ const matchRule_1 = __importDefault(require("./matchRule"));
  */
 function createTextToken(state, isInline, text) {
     const rule = isInline ? defaultRules_1.default.inlineRule : defaultRules_1.default.blockRule;
-    return matchRule_1.default(state, rule, text).get(0);
+    return (0, matchRule_1.default)(state, rule, text).get(0);
 }
 /**
  * Convert a normal text into a list of unstyled tokens (block or inline)

package/lib/render/state.js

@@ -11,7 +11,7 @@ function RenderingState(syntax, options) {
         return new RenderingState(syntax);
     }
     this.syntax = syntax;
-    this.options = options_1.default(options || {});
+    this.options = (0, options_1.default)(options || {});
 }
 /**
  * Render a token using a set of rules

package/lib/utils/walk.js

@@ -18,7 +18,7 @@ function walk(base, iter) {
     let offset = 0;
     const tokens = base.getTokens();
     if (tokens.size === 0) {
-        iter(base, range_utils_1.default(0, base.getText().length));
+        iter(base, (0, range_utils_1.default)(0, base.getText().length));
         return base.getText();
     }
     return tokens.reduce((output, token) => {
@@ -29,7 +29,7 @@ function walk(base, iter) {
             const realRange = range_utils_1.default.moveBy(range, offset);
             iter(tok, realRange);
         });
-        iter(token, range_utils_1.default(offset, innerText.length));
+        iter(token, (0, range_utils_1.default)(offset, innerText.length));
         offset += innerText.length;
         return output + innerText;
     }, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honkit/markup-it",
-  "version": "3.6.17",
+  "version": "3.7.2",
   "description": "Pipeline for working with markup input (for example Markdown)",
   "keywords": [
     "draft-js",
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3c9062a1ecd6c27fde465a1004a5a0b498689b9d"
+  "gitHead": "89e4ff9d86596d7c650c5e83e2d768435d6eef20"
 }

package/syntaxes/markdown/__tests__/specs/amps_and_angles_encoding.html

@@ -0,0 +1,17 @@
+<p>AT&amp;T has an ampersand in their name.</p>
+
+<p>AT&amp;T is another way to write it.</p>
+
+<p>This &amp; that.</p>
+
+<p>4 &lt; 5.</p>
+
+<p>6 &gt; 5.</p>
+
+<p>Here&apos;s a <a href="http://example.com/?foo=1&amp;bar=2">link</a> with an ampersand in the URL.</p>
+
+<p>Here&apos;s a link with an amersand in the link text: <a href="http://att.com/" title="AT&amp;T">AT&amp;T</a>.</p>
+
+<p>Here&apos;s an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>
+
+<p>Here&apos;s an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>

package/syntaxes/markdown/__tests__/specs/amps_and_angles_encoding.md

@@ -0,0 +1,21 @@
+AT&T has an ampersand in their name.
+
+AT&T is another way to write it.
+
+This & that.
+
+4 < 5.
+
+6 > 5.
+
+Here's a [link] [1] with an ampersand in the URL.
+
+Here's a link with an amersand in the link text: [AT&T] [2].
+
+Here's an inline [link](/script?foo=1&bar=2).
+
+Here's an inline [link](</script?foo=1&bar=2>).
+
+
+[1]: http://example.com/?foo=1&bar=2
+[2]: http://att.com/  "AT&T"

package/syntaxes/markdown/__tests__/specs/auto_links.html

@@ -0,0 +1,18 @@
+<p>Link: <a href="http://example.com/">http://example.com/</a>.</p>
+
+<p>With an ampersand: <a href="http://example.com/?foo=1&amp;bar=2">http://example.com/?foo=1&amp;bar=2</a></p>
+
+<ul>
+<li>In a list?</li>
+<li><a href="http://example.com/">http://example.com/</a></li>
+<li>It should.</li>
+</ul>
+
+<blockquote>
+  <p>Blockquoted: <a href="http://example.com/">http://example.com/</a></p>
+</blockquote>
+
+<p>Auto-links should not occur here: <code>&lt;http://example.com/&gt;</code></p>
+
+<pre><code>or here: &lt;http://example.com/&gt;
+</code></pre>

package/syntaxes/markdown/__tests__/specs/auto_links.md

@@ -0,0 +1,13 @@
+Link: <http://example.com/>.
+
+With an ampersand: <http://example.com/?foo=1&bar=2>
+
+* In a list?
+* <http://example.com/>
+* It should.
+
+> Blockquoted: <http://example.com/>
+
+Auto-links should not occur here: `<http://example.com/>`
+
+	or here: <http://example.com/>

package/syntaxes/markdown/__tests__/specs/autolink_lines.html

@@ -0,0 +1,3 @@
+<p>hello world
+<a href="http://example.com">http://example.com</a>
+</p>

package/syntaxes/markdown/__tests__/specs/autolink_lines.md

@@ -0,0 +1,2 @@
+hello world
+<http://example.com>

package/syntaxes/markdown/__tests__/specs/backslash_escapes.html

@@ -0,0 +1,118 @@
+<p>These should all get escaped:</p>
+
+<p>Backslash: \</p>
+
+<p>Backtick: `</p>
+
+<p>Asterisk: *</p>
+
+<p>Underscore: _</p>
+
+<p>Left brace: {</p>
+
+<p>Right brace: }</p>
+
+<p>Left bracket: [</p>
+
+<p>Right bracket: ]</p>
+
+<p>Left paren: (</p>
+
+<p>Right paren: )</p>
+
+<p>Greater-than: ></p>
+
+<p>Hash: #</p>
+
+<p>Period: .</p>
+
+<p>Bang: !</p>
+
+<p>Plus: +</p>
+
+<p>Minus: -</p>
+
+<p>These should not, because they occur within a code block:</p>
+
+<pre><code>Backslash: \\
+
+Backtick: \`
+
+Asterisk: \*
+
+Underscore: \_
+
+Left brace: \{
+
+Right brace: \}
+
+Left bracket: \[
+
+Right bracket: \]
+
+Left paren: \(
+
+Right paren: \)
+
+Greater-than: \&gt;
+
+Hash: \#
+
+Period: \.
+
+Bang: \!
+
+Plus: \+
+
+Minus: \-
+</code></pre>
+
+<p>Nor should these, which occur in code spans:</p>
+
+<p>Backslash: <code>\\</code></p>
+
+<p>Backtick: <code>\`</code></p>
+
+<p>Asterisk: <code>\*</code></p>
+
+<p>Underscore: <code>\_</code></p>
+
+<p>Left brace: <code>\{</code></p>
+
+<p>Right brace: <code>\}</code></p>
+
+<p>Left bracket: <code>\[</code></p>
+
+<p>Right bracket: <code>\]</code></p>
+
+<p>Left paren: <code>\(</code></p>
+
+<p>Right paren: <code>\)</code></p>
+
+<p>Greater-than: <code>\&gt;</code></p>
+
+<p>Hash: <code>\#</code></p>
+
+<p>Period: <code>\.</code></p>
+
+<p>Bang: <code>\!</code></p>
+
+<p>Plus: <code>\+</code></p>
+
+<p>Minus: <code>\-</code></p>
+
+
+<p>These should get escaped, even though they&apos;re matching pairs for
+other Markdown constructs:</p>
+
+<p>*asterisks*</p>
+
+<p>_underscores_</p>
+
+<p>`backticks`</p>
+
+<p>This is a code span with a literal backslash-backtick sequence: <code>\`</code></p>
+
+<p>This is a tag with unescaped backticks <span attr='`ticks`'>bar</span>.</p>
+
+<p>This is a tag with backslashes <span attr='\\backslashes\\'>bar</span>.</p>