securemark 0.224.1 → 0.225.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.225.0
+
+- Refine some parsers to disallow trailing whitespace.
+
 ## 0.224.1
 
 - Refactoring.

package/dist/securemark.js

@@ -1,4 +1,4 @@
-/*! securemark v0.224.1 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED */
+/*! securemark v0.225.0 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED */
 require = function () {
     function r(e, n, t) {
         function o(i, f) {
@@ -6966,7 +6966,7 @@ require = function () {
             const typed_dom_1 = _dereq_('typed-dom');
             const array_1 = _dereq_('spica/array');
             exports.deletion = (0, combinator_1.lazy)(() => (0, combinator_1.creator)((0, combinator_1.surround)((0, source_1.str)('~~'), (0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, '~~')]), (0, source_1.str)('~~'), false, ([, bs], rest) => [
-                [(0, typed_dom_1.html)('del', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))],
+                [(0, typed_dom_1.html)('del', (0, typed_dom_1.defrag)((0, util_1.trimNodeEndBR)(bs)))],
                 rest
             ], ([as, bs], rest) => [
                 (0, array_1.unshift)(as, bs),
@@ -6998,7 +6998,7 @@ require = function () {
                 strong_1.strong,
                 (0, combinator_1.some)(inline_1.inline, '*')
             ]))), (0, source_1.str)('*'), false, ([as, bs, cs], rest) => (0, util_1.isEndTightNodes)(bs) ? [
-                [(0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))],
+                [(0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)(bs))],
                 rest
             ] : [
                 (0, array_1.unshift)(as, bs),
@@ -7039,41 +7039,41 @@ require = function () {
                 switch (cs[0]) {
                 case '*':
                     return (_a = (0, combinator_1.bind)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, '**')]), (ds, rest) => rest.slice(0, 2) === '**' && (0, util_1.isEndTightNodes)(ds) ? [
-                        [(0, typed_dom_1.html)('strong', (0, array_1.unshift)([(0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))], (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(ds))))],
+                        [(0, typed_dom_1.html)('strong', (0, array_1.unshift)([(0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)(bs))], (0, typed_dom_1.defrag)(ds)))],
                         rest.slice(2)
                     ] : [
                         (0, array_1.unshift)([
                             '**',
-                            (0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))
+                            (0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)(bs))
                         ], ds),
                         rest
                     ])(rest, context)) !== null && _a !== void 0 ? _a : [
                         [
                             '**',
-                            (0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))
+                            (0, typed_dom_1.html)('em', (0, typed_dom_1.defrag)(bs))
                         ],
                         rest
                     ];
                 case '**':
                     return (_b = (0, combinator_1.bind)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, '*')]), (ds, rest) => rest.slice(0, 1) === '*' && (0, util_1.isEndTightNodes)(ds) ? [
-                        [(0, typed_dom_1.html)('em', (0, array_1.unshift)([(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))], (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(ds))))],
+                        [(0, typed_dom_1.html)('em', (0, array_1.unshift)([(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)(bs))], (0, typed_dom_1.defrag)(ds)))],
                         rest.slice(1)
                     ] : [
                         (0, array_1.unshift)([
                             '*',
-                            (0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))
+                            (0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)(bs))
                         ], ds),
                         rest
                     ])(rest, context)) !== null && _b !== void 0 ? _b : [
                         [
                             '*',
-                            (0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))
+                            (0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)(bs))
                         ],
                         rest
                     ];
                 case '***':
                     return [
-                        [(0, typed_dom_1.html)('em', [(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))])],
+                        [(0, typed_dom_1.html)('em', [(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)(bs))])],
                         rest
                     ];
                 }
@@ -7441,11 +7441,11 @@ require = function () {
                         return {};
                     }
                 })(), (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), `</${ tag }>`)), `</${ tag }>`), (0, source_1.str)(`</${ tag }>`), false, ([as, bs, cs], rest, context) => [
-                    [elem(tag, as, (0, util_1.trimEndBR)((0, typed_dom_1.defrag)(bs)), cs, context)],
+                    [elem(tag, as, (0, util_1.trimNodeEndBR)((0, typed_dom_1.defrag)(bs)), cs, context)],
                     rest
                 ])), ([, tag]) => tag)),
                 (0, combinator_1.match)(/^(?=<([a-z]+)(?=[^\S\n]|>))/, (0, memoize_1.memoize)(([, tag]) => (0, combinator_1.validate)(`<${ tag }`, `</${ tag }>`, (0, combinator_1.surround)((0, combinator_1.surround)((0, source_1.str)(`<${ tag }`), (0, combinator_1.some)(exports.attribute), (0, source_1.str)('>'), true), (0, util_1.startLoose)((0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), `</${ tag }>`), `</${ tag }>`), (0, source_1.str)(`</${ tag }>`), false, ([as, bs, cs], rest) => [
-                    [elem(tag, as, (0, util_1.trimEndBR)((0, typed_dom_1.defrag)(bs)), cs, {})],
+                    [elem(tag, as, (0, util_1.trimNodeEndBR)((0, typed_dom_1.defrag)(bs)), cs, {})],
                     rest
                 ], ([as, bs], rest) => as.length === 1 ? [
                     (0, array_1.unshift)(as, bs),
@@ -7561,7 +7561,7 @@ require = function () {
             const typed_dom_1 = _dereq_('typed-dom');
             const array_1 = _dereq_('spica/array');
             exports.insertion = (0, combinator_1.lazy)(() => (0, combinator_1.creator)((0, combinator_1.surround)((0, source_1.str)('++'), (0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, '++')]), (0, source_1.str)('++'), false, ([, bs], rest) => [
-                [(0, typed_dom_1.html)('ins', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))],
+                [(0, typed_dom_1.html)('ins', (0, typed_dom_1.defrag)((0, util_1.trimNodeEndBR)(bs)))],
                 rest
             ], ([as, bs], rest) => [
                 (0, array_1.unshift)(as, bs),
@@ -7733,7 +7733,7 @@ require = function () {
             const typed_dom_1 = _dereq_('typed-dom');
             const array_1 = _dereq_('spica/array');
             exports.mark = (0, combinator_1.lazy)(() => (0, combinator_1.creator)((0, combinator_1.surround)((0, source_1.str)('=='), (0, util_1.startTight)((0, combinator_1.union)([(0, combinator_1.some)(inline_1.inline, '==')])), (0, source_1.str)('=='), false, ([as, bs, cs], rest) => (0, util_1.isEndTightNodes)(bs) ? [
-                [(0, typed_dom_1.html)('mark', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))],
+                [(0, typed_dom_1.html)('mark', (0, typed_dom_1.defrag)(bs))],
                 rest
             ] : [
                 (0, array_1.unshift)(as, bs),
@@ -8123,7 +8123,7 @@ require = function () {
                 (0, combinator_1.some)(inline_1.inline, '*'),
                 (0, source_1.str)('*')
             ]), '**')), (0, source_1.str)('**'), false, ([as, bs, cs], rest) => (0, util_1.isEndTightNodes)(bs) ? [
-                [(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)((0, util_1.trimEndBR)(bs)))],
+                [(0, typed_dom_1.html)('strong', (0, typed_dom_1.defrag)(bs))],
                 rest
             ] : [
                 (0, array_1.unshift)(as, bs),
@@ -8886,7 +8886,7 @@ require = function () {
         function (_dereq_, module, exports) {
             'use strict';
             Object.defineProperty(exports, '__esModule', { value: true });
-            exports.stringify = exports.trimEndBR = exports.trimNodeEnd = exports.trimNode = exports.isEndTightNodes = exports.isStartTightNodes = exports.startTight = exports.isStartLoose = exports.startLoose = exports.visualize = void 0;
+            exports.stringify = exports.trimNodeEndBR = exports.trimNodeEnd = exports.trimNode = exports.isEndTightNodes = exports.isStartTightNodes = exports.startTight = exports.isStartLoose = exports.startLoose = exports.visualize = void 0;
             const global_1 = _dereq_('spica/global');
             const parser_1 = _dereq_('../combinator/data/parser');
             const combinator_1 = _dereq_('../combinator');
@@ -9020,8 +9020,7 @@ require = function () {
             function isEndTightNodes(nodes) {
                 if (nodes.length === 0)
                     return true;
-                const last = nodes.length - 1;
-                return typeof nodes[last] === 'string' && nodes[last].length > 1 ? isVisible(nodes[last], -1) || isVisible(nodes[last], -2) : isVisible(nodes[last], -1) || last === 0 || isVisible(nodes[last - 1], -1);
+                return isVisible(nodes[nodes.length - 1], -1);
             }
             exports.isEndTightNodes = isEndTightNodes;
             function isVisible(node, position) {
@@ -9085,13 +9084,13 @@ require = function () {
                 return (0, array_1.push)(nodes, skip);
             }
             exports.trimNodeEnd = trimNodeEnd;
-            function trimEndBR(nodes) {
+            function trimNodeEndBR(nodes) {
                 if (nodes.length === 0)
                     return nodes;
                 const node = nodes[nodes.length - 1];
                 return typeof node === 'object' && node.tagName === 'BR' ? (0, array_1.pop)(nodes)[0] : nodes;
             }
-            exports.trimEndBR = trimEndBR;
+            exports.trimNodeEndBR = trimNodeEndBR;
             function stringify(nodes) {
                 let acc = '';
                 for (let i = 0; i < nodes.length; ++i) {

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.224.1",
+  "version": "0.225.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.224.1",
+  "version": "0.225.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/parser/api/parse.test.ts

@@ -60,9 +60,6 @@ describe('Unit: parser/api/parse', () => {
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(
-        [...parse('*a\n*\nb').children].map(el => el.outerHTML),
-        ['<p><em>a</em><br>b</p>']);
       assert.deepStrictEqual(
         [...parse('\\ ').children].map(el => el.outerHTML),
         ['<p>\\</p>']);

package/src/parser/inline/deletion.test.ts

@@ -32,8 +32,6 @@ describe('Unit: parser/inline/deletion', () => {
       assert.deepStrictEqual(inspect(parser('~~a\\\nb~~')), [['<del>a<span class="linebreak"> </span>b</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~\\~~~')), [['<del>~</del>'], '']);
       assert.deepStrictEqual(inspect(parser('~~a~~~')), [['<del>a</del>'], '~']);
-      assert.deepStrictEqual(inspect(parser('~~~a~~')), [['<del>~a</del>'], '']);
-      assert.deepStrictEqual(inspect(parser('~~~a~~~')), [['<del>~a</del>'], '~']);
     });
 
     it('nest', () => {

package/src/parser/inline/deletion.ts

@@ -2,7 +2,7 @@ import { DeletionParser } from '../inline';
 import { union, some, creator, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { trimEndBR } from '../util';
+import { trimNodeEndBR } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -10,5 +10,5 @@ export const deletion: DeletionParser = lazy(() => creator(surround(
   str('~~'),
   union([some(inline, '~~')]),
   str('~~'), false,
-  ([, bs], rest) => [[html('del', defrag(trimEndBR(bs)))], rest],
+  ([, bs], rest) => [[html('del', defrag(trimNodeEndBR(bs)))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/emphasis.test.ts

@@ -9,7 +9,10 @@ describe('Unit: parser/inline/emphasis', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('*')), undefined);
       assert.deepStrictEqual(inspect(parser('*a')), [['*', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('*a  *')), [['*', 'a', '  '], '*']);
+      assert.deepStrictEqual(inspect(parser('*a *')), [['*', 'a', ' '], '*']);
+      assert.deepStrictEqual(inspect(parser('*a\n*')), [['*', 'a', '<br>'], '*']);
+      assert.deepStrictEqual(inspect(parser('*a\\ *')), [['*', 'a', ' '], '*']);
+      assert.deepStrictEqual(inspect(parser('*a\\\n*')), [['*', 'a', '<span class="linebreak"> </span>'], '*']);
       assert.deepStrictEqual(inspect(parser('*a**b')), [['*', 'a', '**', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b*')), [['*', 'a', '**', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('* *')), undefined);
@@ -28,9 +31,6 @@ describe('Unit: parser/inline/emphasis', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('*a*')), [['<em>a</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a *')), [['<em>a </em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\n*')), [['<em>a</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\\n*')), [['<em>a<span class="linebreak"> </span></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*ab*')), [['<em>ab</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<em>a<br>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<em>a<span class="linebreak"> </span>b</em>'], '']);

package/src/parser/inline/emphasis.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, close, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
-import { startTight, isEndTightNodes, trimEndBR } from '../util';
+import { startTight, isEndTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -13,6 +13,6 @@ export const emphasis: EmphasisParser = lazy(() => creator(surround(close(
   str('*'), false,
   ([as, bs, cs], rest) =>
     isEndTightNodes(bs)
-      ? [[html('em', defrag(trimEndBR(bs)))], rest]
+      ? [[html('em', defrag(bs))], rest]
       : [unshift(as, bs), cs[0] + rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/emstrong.ts

@@ -2,7 +2,7 @@ import { EmStrongParser } from '../inline';
 import { union, some, creator, surround, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes, trimEndBR } from '../util';
+import { startTight, isEndTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -18,19 +18,19 @@ export const emstrong: EmStrongParser = lazy(() => creator(surround(
           union([some(inline, '**')]),
           (ds, rest) =>
             rest.slice(0, 2) === '**' && isEndTightNodes(ds)
-              ? [[html('strong', unshift([html('em', defrag(trimEndBR(bs)))], defrag(trimEndBR(ds))))], rest.slice(2)]
-              : [unshift(['**', html('em', defrag(trimEndBR(bs)))], ds), rest])
-          (rest, context) ?? [['**', html('em', defrag(trimEndBR(bs)))], rest];
+              ? [[html('strong', unshift([html('em', defrag(bs))], defrag(ds)))], rest.slice(2)]
+              : [unshift(['**', html('em', defrag(bs))], ds), rest])
+          (rest, context) ?? [['**', html('em', defrag(bs))], rest];
       case '**':
         return bind<EmStrongParser>(
           union([some(inline, '*')]),
           (ds, rest) =>
             rest.slice(0, 1) === '*' && isEndTightNodes(ds)
-              ? [[html('em', unshift([html('strong', defrag(trimEndBR(bs)))], defrag(trimEndBR(ds))))], rest.slice(1)]
-              : [unshift(['*', html('strong', defrag(trimEndBR(bs)))], ds), rest])
-          (rest, context) ?? [['*', html('strong', defrag(trimEndBR(bs)))], rest];
+              ? [[html('em', unshift([html('strong', defrag(bs))], defrag(ds)))], rest.slice(1)]
+              : [unshift(['*', html('strong', defrag(bs))], ds), rest])
+          (rest, context) ?? [['*', html('strong', defrag(bs))], rest];
       case '***':
-        return [[html('em', [html('strong', defrag(trimEndBR(bs)))])], rest];
+        return [[html('em', [html('strong', defrag(bs))])], rest];
     }
     assert(false);
   },

package/src/parser/inline/html.ts

@@ -5,7 +5,7 @@ import { HTMLParser } from '../inline';
 import { union, some, validate, context, creator, surround, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startLoose, trimEndBR } from '../util';
+import { startLoose, trimNodeEndBR } from '../util';
 import { html as h, defrag } from 'typed-dom';
 import { memoize } from 'spica/memoize';
 import { Cache } from 'spica/cache';
@@ -66,7 +66,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', '>', '\n', vali
         some(union([inline]), `</${tag}>`)), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest, context) =>
-          [[elem(tag, as, trimEndBR(defrag(bs)), cs, context)], rest])),
+          [[elem(tag, as, trimNodeEndBR(defrag(bs)), cs, context)], rest])),
       ([, tag]) => tag)),
   match(
     /^(?=<([a-z]+)(?=[^\S\n]|>))/,
@@ -78,7 +78,7 @@ export const html: HTMLParser = lazy(() => creator(validate('<', '>', '\n', vali
         startLoose(some(union([inline]), `</${tag}>`), `</${tag}>`),
         str(`</${tag}>`), false,
         ([as, bs, cs], rest) =>
-          [[elem(tag, as, trimEndBR(defrag(bs)), cs, {})], rest],
+          [[elem(tag, as, trimNodeEndBR(defrag(bs)), cs, {})], rest],
         ([as, bs], rest) =>
           as.length === 1
             ? [unshift(as, bs), rest]

package/src/parser/inline/insertion.test.ts

@@ -32,8 +32,6 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<span class="linebreak"> </span>b</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\+++')), [['<ins>+</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a+++')), [['<ins>a</ins>'], '+']);
-      assert.deepStrictEqual(inspect(parser('+++a++')), [['<ins>+a</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('+++a+++')), [['<ins>+a</ins>'], '+']);
     });
 
     it('nest', () => {

package/src/parser/inline/insertion.ts

@@ -2,7 +2,7 @@ import { InsertionParser } from '../inline';
 import { union, some, creator, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { trimEndBR } from '../util';
+import { trimNodeEndBR } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -10,5 +10,5 @@ export const insertion: InsertionParser = lazy(() => creator(surround(
   str('++'),
   union([some(inline, '++')]),
   str('++'), false,
-  ([, bs], rest) => [[html('ins', defrag(trimEndBR(bs)))], rest],
+  ([, bs], rest) => [[html('ins', defrag(trimNodeEndBR(bs)))], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/mark.test.ts

@@ -12,7 +12,10 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('==')), undefined);
       assert.deepStrictEqual(inspect(parser('==a')), [['==', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('==a=')), [['==', 'a', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a  ==')), [['==', 'a', '  '], '==']);
+      assert.deepStrictEqual(inspect(parser('==a ==')), [['==', 'a', ' '], '==']);
+      assert.deepStrictEqual(inspect(parser('==a\n==')), [['==', 'a', '<br>'], '==']);
+      assert.deepStrictEqual(inspect(parser('==a\\ ==')), [['==', 'a', ' '], '==']);
+      assert.deepStrictEqual(inspect(parser('==a\\\n==')), [['==', 'a', '<span class="linebreak"> </span>'], '==']);
       assert.deepStrictEqual(inspect(parser('== ==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a ==')), undefined);
@@ -26,14 +29,10 @@ describe('Unit: parser/inline/mark', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('==a==')), [['<mark>a</mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==ab==')), [['<mark>ab</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a ==')), [['<mark>a </mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a\n==')), [['<mark>a</mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\nb==')), [['<mark>a<br>b</mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\\\nb==')), [['<mark>a<span class="linebreak"> </span>b</mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark>=</mark>'], '']);
       assert.deepStrictEqual(inspect(parser('==a===')), [['<mark>a</mark>'], '=']);
-      assert.deepStrictEqual(inspect(parser('===a==')), [['<mark>=a</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('===a===')), [['<mark>=a</mark>'], '=']);
     });
 
     it('nest', () => {

package/src/parser/inline/mark.ts

@@ -2,7 +2,7 @@ import { MarkParser } from '../inline';
 import { union, some, creator, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTightNodes, trimEndBR } from '../util';
+import { startTight, isEndTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -12,6 +12,6 @@ export const mark: MarkParser = lazy(() => creator(surround(
   str('=='), false,
   ([as, bs, cs], rest) =>
     isEndTightNodes(bs)
-      ? [[html('mark', defrag(trimEndBR(bs)))], rest]
+      ? [[html('mark', defrag(bs))], rest]
       : [unshift(as, bs), cs[0] + rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/math.test.ts

@@ -23,6 +23,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$-0$-1')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a$')), undefined);
       assert.deepStrictEqual(inspect(parser('$-a$-b')), undefined);
+      assert.deepStrictEqual(inspect(parser('$a $')), undefined);
       assert.deepStrictEqual(inspect(parser('$a-b$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a-b$c-d')), undefined);
       assert.deepStrictEqual(inspect(parser('$a+b$')), undefined);
@@ -33,6 +34,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$a$b')), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b$')), undefined);
       assert.deepStrictEqual(inspect(parser('$ $')), undefined);
+      assert.deepStrictEqual(inspect(parser('$ a$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$ a $')), undefined);
       assert.deepStrictEqual(inspect(parser('$\n$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\nb$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\\\nb$')), undefined);
@@ -59,6 +62,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('${}$')), [['<span class="math" translate="no" data-src="${}$">${}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ }$')), [['<span class="math" translate="no" data-src="${ }$">${ }$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${a}$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${a}$$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '$']);
       assert.deepStrictEqual(inspect(parser('${a}$0')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '0']);
       assert.deepStrictEqual(inspect(parser('${a}$b')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], 'b']);
       assert.deepStrictEqual(inspect(parser('${ab}$')), [['<span class="math" translate="no" data-src="${ab}$">${ab}$</span>'], '']);
@@ -71,14 +75,15 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('${\\$}$')), [['<span class="math" translate="no" data-src="${\\$}$">${\\$}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\\\}$')), [['<span class="math" translate="no" data-src="${\\\\}$">${\\\\}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$a$$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '$']);
       assert.deepStrictEqual(inspect(parser(`$a'$`)), [[`<span class="math" translate="no" data-src="$a'$">$a'$</span>`], '']);
       assert.deepStrictEqual(inspect(parser(`$a''$`)), [[`<span class="math" translate="no" data-src="$a''$">$a''$</span>`], '']);
       assert.deepStrictEqual(inspect(parser('$a$[A](a)')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '[A](a)']);
-      assert.deepStrictEqual(inspect(parser('$a$$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '$']);
       assert.deepStrictEqual(inspect(parser('$A$')), [['<span class="math" translate="no" data-src="$A$">$A$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\$$')), [['<span class="math" translate="no" data-src="$\\$$">$\\$$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\Pi$')), [['<span class="math" translate="no" data-src="$\\Pi$">$\\Pi$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$\\Pi $')), [['<span class="math" translate="no" data-src="$\\Pi $">$\\Pi $</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\ 0$')), [['<span class="math" translate="no" data-src="$\\ 0$">$\\ 0$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\\\0$')), [['<span class="math" translate="no" data-src="$\\\\0$">$\\\\0$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$|1|$')), [['<span class="math" translate="no" data-src="$|1|$">$|1|$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$[0,1)$]')), [['<span class="math" translate="no" data-src="$[0,1)$">$[0,1)$</span>'], ']']);
       assert.deepStrictEqual(inspect(parser('$(0, 1]$)')), [['<span class="math" translate="no" data-src="$(0, 1]$">$(0, 1]$</span>'], ')']);

package/src/parser/inline/strong.test.ts

@@ -10,7 +10,10 @@ describe('Unit: parser/inline/strong', () => {
       assert.deepStrictEqual(inspect(parser('**')), undefined);
       assert.deepStrictEqual(inspect(parser('**a')), [['**', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('**a  **')), [['**', 'a', '  '], '**']);
+      assert.deepStrictEqual(inspect(parser('**a **')), [['**', 'a', ' '], '**']);
+      assert.deepStrictEqual(inspect(parser('**a\n**')), [['**', 'a', '<br>'], '**']);
+      assert.deepStrictEqual(inspect(parser('**a\\ **')), [['**', 'a', ' '], '**']);
+      assert.deepStrictEqual(inspect(parser('**a\\\n**')), [['**', 'a', '<span class="linebreak"> </span>'], '**']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** **')), undefined);
       assert.deepStrictEqual(inspect(parser('** a**')), undefined);
@@ -27,15 +30,12 @@ describe('Unit: parser/inline/strong', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('**a**')), [['<strong>a</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **')), [['<strong>a </strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\n**')), [['<strong>a</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a\\\n**')), [['<strong>a<span class="linebreak"> </span></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**ab**')), [['<strong>ab</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a\nb**')), [['<strong>a<br>b</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a\\\nb**')), [['<strong>a<span class="linebreak"> </span>b</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b*c**')), [['<strong>a<em>b</em>c</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b*c**d')), [['<strong>a<em>b</em>c</strong>'], 'd']);
-      assert.deepStrictEqual(inspect(parser('**a  *b***')), [['<strong>a  <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a *b***')), [['<strong>a <em>b</em></strong>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/strong.ts

@@ -3,7 +3,7 @@ import { union, some, creator, surround, close, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { startTight, isEndTightNodes, trimEndBR } from '../util';
+import { startTight, isEndTightNodes } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
@@ -13,6 +13,6 @@ export const strong: StrongParser = lazy(() => creator(surround(close(
   str('**'), false,
   ([as, bs, cs], rest) =>
     isEndTightNodes(bs)
-      ? [[html('strong', defrag(trimEndBR(bs)))], rest]
+      ? [[html('strong', defrag(bs))], rest]
       : [unshift(as, bs), cs[0] + rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline.test.ts

@@ -30,18 +30,16 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a**b*c')), [['*', 'a', '**', 'b', '*', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b*c*')), [['*', 'a', '**', 'b', '<em>c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b**')), [['*', 'a', '<strong>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a  **b***')), [['<em>a  <strong>b</strong></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a  **b***c')), [['<em>a  <strong>b</strong></em>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('*a **b***')), [['<em>a <strong>b</strong></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a **b***c')), [['<em>a <strong>b</strong></em>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**c')), [['**', 'a', '*', 'b', '**', 'c'], '']);
-      assert.deepStrictEqual(inspect(parser('**a  *b***')), [['<strong>a  <em>b</em></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('**a  *b***c')), [['<strong>a  <em>b</em></strong>', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('**a *b***')), [['<strong>a <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a *b***c')), [['<strong>a <em>b</em></strong>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b**')), [['<strong><em>a</em>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b  **')), [['**', '<em>a</em>', 'b', '  ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('***a* b**')), [['<strong><em>a</em> b</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*')), [['<em><strong>a</strong>b</em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b  *')), [['*', '<strong>a</strong>', 'b', '  ', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a** b*')), [['<em><strong>a</strong> b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*')), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**')), [['*', '<strong>a</strong>'], '']);

package/src/parser/util.ts

@@ -135,12 +135,7 @@ export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boo
 }
 export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
-  const last = nodes.length - 1;
-  return typeof nodes[last] === 'string' && (nodes[last] as string).length > 1
-    ? isVisible(nodes[last], -1) ||
-      isVisible(nodes[last], -2)
-    : isVisible(nodes[last], -1) || last === 0 ||
-      isVisible(nodes[last - 1], -1);
+  return isVisible(nodes[nodes.length - 1], -1);
 }
 function isVisible(node: HTMLElement | string, position?: number): boolean {
   if (!node) return false;
@@ -224,8 +219,8 @@ export function trimNodeEnd(nodes: (HTMLElement | string)[]): (HTMLElement | str
   }
   return push(nodes, skip);
 }
-export function trimEndBR<T extends HTMLElement | string>(nodes: T[]): T[];
-export function trimEndBR(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
+export function trimNodeEndBR<T extends HTMLElement | string>(nodes: T[]): T[];
+export function trimNodeEndBR(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
   if (nodes.length === 0) return nodes;
   const node = nodes[nodes.length - 1];
   return typeof node === 'object' && node.tagName === 'BR'