@honkit/markup-it 6.0.3 → 6.1.4

package/lib/__tests__/syntax.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=syntax.d.ts.map

package/lib/__tests__/syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.d.ts","sourceRoot":"","sources":["../../src/__tests__/syntax.ts"],"names":[],"mappings":""}

package/lib/__tests__/syntax.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const MarkupIt = __importStar(require(".."));
+describe("Custom Syntax", () => {
+    const syntax = MarkupIt.Syntax("mysyntax", {
+        inline: [
+            MarkupIt.Rule(MarkupIt.STYLES.BOLD)
+                .regExp(/^\*\*([\s\S]+?)\*\*/, (state, match) => {
+                return {
+                    text: match[1],
+                };
+            })
+                .toText("**%s**"),
+        ],
+    });
+    const markup = new MarkupIt.Markup(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(MarkupIt.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(MarkupIt.BLOCKS.TEXT);
+            p.getAsPlainText().should.equal("Hello World");
+        });
+    });
+    describe(".toText", () => {
+        it("should output correct string", () => {
+            const content = MarkupIt.JSONUtils.decode({
+                syntax: "mysyntax",
+                token: {
+                    type: MarkupIt.BLOCKS.DOCUMENT,
+                    tokens: [
+                        {
+                            type: MarkupIt.BLOCKS.PARAGRAPH,
+                            tokens: [
+                                {
+                                    type: MarkupIt.STYLES.TEXT,
+                                    text: "Hello ",
+                                },
+                                {
+                                    type: MarkupIt.STYLES.BOLD,
+                                    text: "World",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            });
+            const text = markup.toText(content);
+            text.should.equal("Hello **World**\n");
+        });
+    });
+});

package/lib/json/__tests__/decode.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=decode.d.ts.map

package/lib/json/__tests__/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/json/__tests__/decode.ts"],"names":[],"mappings":""}

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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=encode.d.ts.map

package/lib/json/__tests__/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/json/__tests__/encode.ts"],"names":[],"mappings":""}

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/models/__tests__/token.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=token.d.ts.map

package/lib/models/__tests__/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../src/models/__tests__/token.ts"],"names":[],"mappings":""}

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/parse/__tests__/mergeTokens.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mergeTokens.d.ts.map

package/lib/parse/__tests__/mergeTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeTokens.d.ts","sourceRoot":"","sources":["../../../src/parse/__tests__/mergeTokens.ts"],"names":[],"mappings":""}

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/textToUnstyledTokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"textToUnstyledTokens.d.ts","sourceRoot":"","sources":["../../src/parse/textToUnstyledTokens.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,WAAW,CAAC;AAkBlC;;;;;;;GAOG;AACH,iBAAS,oBAAoB,CAAC,KAAK,KAAA,EAAE,QAAQ,KAAA,EAAE,IAAI,KAAA,uBAkClD;AAED,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"textToUnstyledTokens.d.ts","sourceRoot":"","sources":["../../src/parse/textToUnstyledTokens.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,WAAW,CAAC;AAkBlC;;;;;;;GAOG;AACH,iBAAS,oBAAoB,CAAC,KAAK,KAAA,EAAE,QAAQ,KAAA,EAAE,IAAI,KAAA,uBAgClD;AAED,eAAe,oBAAoB,CAAC"}

package/lib/parse/textToUnstyledTokens.js

@@ -40,8 +40,7 @@ function textToUnstyledTokens(state, isInline, text) {
             result.push(token);
         }
     }
-    for (let i = 0; i < text.length; i++) {
-        c = text[i];
+    for (const c of text) {
         if (c !== "\n" && wasNewLine) {
             pushAccu();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honkit/markup-it",
-  "version": "6.0.3",
+  "version": "6.1.4",
   "description": "Pipeline for working with markup input (for example Markdown)",
   "keywords": [
     "draft-js",
@@ -8,13 +8,13 @@
     "asciidoc",
     "gitbook"
   ],
-  "homepage": "https://github.com/GitbookIO/markup-it#readme",
+  "homepage": "https://github.com/honkit/honkit#readme",
   "bugs": {
-    "url": "https://github.com/GitbookIO/markup-it/issues"
+    "url": "https://github.com/honkit/honkit/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/GitbookIO/draft-markup.git"
+    "url": "https://github.com/honkit/honkit.git"
   },
   "license": "Apache-2.0",
   "author": "azu",
@@ -24,13 +24,6 @@
     "syntaxes",
     "!__tests__"
   ],
-  "scripts": {
-    "build": "tsc -p .",
-    "clean": "rimraf lib/",
-    "lint": "eslint .",
-    "test": "jest",
-    "prepublish": "npm run --if-present build"
-  },
   "dependencies": {
     "escape-string-regexp": "^4.0.0",
     "html-entities": "^1.4.0",
@@ -41,18 +34,24 @@
     "range-utils": "^1.1.0"
   },
   "devDependencies": {
-    "@honkit/cleaning-tools": "6.0.3",
     "@types/jest": "^29.5.13",
     "@types/node": "^22.7.4",
     "eslint": "^9.12.0",
     "jest": "^29.7.0",
     "jsdom": "^20.0.3",
-    "rimraf": "^3.0.2",
+    "rimraf": "^6.0.1",
     "should": "^13.2.3",
-    "ts-jest": "^29.2.5"
+    "ts-jest": "^29.2.5",
+    "@honkit/cleaning-tools": "6.1.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "608191107875c3d613840d702b76a9888992d7bc"
-}
+  "scripts": {
+    "build": "tsc -p .",
+    "clean": "rimraf lib/",
+    "lint": "eslint .",
+    "test": "jest",
+    "prepublish": "npm run --if-present build"
+  }
+}

package/syntaxes/markdown/__tests__/normalizeTeX.spec.js

@@ -0,0 +1,34 @@
+const { normalizeTeX } = require("../math.js");
+
+describe("normalizeTeX", () => {
+    it(`should normalize`, () => {
+        expect(normalizeTeX("$a$", true)).toMatchInlineSnapshot(`"$a$"`);
+        expect(normalizeTeX("$$a$$", true)).toMatchInlineSnapshot(`"$$a$$"`);
+        expect(normalizeTeX("$a$ $b$", true)).toMatchInlineSnapshot(`"$a$ $b$"`);
+        expect(normalizeTeX("$a$ $b$ $c$", true)).toMatchInlineSnapshot(`"$a$ $b$ $c$"`);
+        expect(normalizeTeX("$a$\n$b$", true)).toMatchInlineSnapshot(`
+            "$a$
+            $b$"
+        `);
+        expect(normalizeTeX("$a$\n\n$b$", true)).toMatchInlineSnapshot(`
+            "$a$
+
+            $b$"
+        `);
+        expect(normalizeTeX("$a$ $b$\n", true)).toMatchInlineSnapshot(`"$a$ $b$"`);
+        expect(normalizeTeX("$a$ $b$\n\n", true)).toMatchInlineSnapshot(`"$a$ $b$"`);
+        expect(normalizeTeX("$a$\n$b$\n", true)).toMatchInlineSnapshot(`
+            "$a$
+            $b$"
+        `);
+        expect(normalizeTeX("$a$\n\n$b$\n\n", true)).toMatchInlineSnapshot(`
+            "$a$
+
+            $b$"
+        `);
+        expect(normalizeTeX("$a$ $b$", true)).toMatchInlineSnapshot(`"$a$ $b$"`);
+        expect(normalizeTeX("$a$  $b$", true)).toMatchInlineSnapshot(`"$a$  $b$"`);
+        expect(normalizeTeX("$a$ $b$ $c$", true)).toMatchInlineSnapshot(`"$a$ $b$ $c$"`);
+        expect(normalizeTeX("$a$  $b$  $c$", true)).toMatchInlineSnapshot(`"$a$  $b$  $c$"`);
+    });
+});

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>