securemark 0.263.1 → 0.264.0

package/src/parser/inline/extension/placeholder.test.ts

@@ -22,12 +22,6 @@ describe('Unit: parser/inline/extension/placeholder', () => {
       assert.deepStrictEqual(inspect(parser('[^\\\na]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^ !http://host]')), undefined);
       assert.deepStrictEqual(inspect(parser('[^a')), [['[^', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\n]')), [['[^', 'a'], '\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\n\n]')), [['[^', 'a'], '\n\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), [['[^', 'a'], '\\\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\n\\\n]')), [['[^', 'a'], '\\\n\\\n]']);
-      assert.deepStrictEqual(inspect(parser('[^a\nb]')), [['[^', 'a'], '\nb]']);
-      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), [['[^', 'a'], '\\\nb]']);
       assert.deepStrictEqual(inspect(parser('[[]')), undefined);
       assert.deepStrictEqual(inspect(parser('[]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[]]')), undefined);
@@ -39,12 +33,16 @@ describe('Unit: parser/inline/extension/placeholder', () => {
     it('valid', () => {
       assert.deepStrictEqual(inspect(parser('[^a]')), [['<span class="invalid">a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a b]')), [['<span class="invalid">a b</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a ]')), [['<span class="invalid">a </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a  ]')), [['<span class="invalid">a  </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ ]')), [['<span class="invalid">a </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a  </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a<wbr></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a<wbr><wbr></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a  ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\ ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\ \\ ]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\n]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\n]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\nb]')), [['<span class="invalid">a<br>b</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a\\\nb]')), [['<span class="invalid">a<br>b</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a<wbr>]')), [['<span class="invalid">a</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[^a<wbr><wbr>]')), [['<span class="invalid">a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^==]')), [['<span class="invalid">==</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a[% b %][% c %]]')), [['<span class="invalid">a<span class="comment"><input type="checkbox"><span>[% b %]</span></span><span class="comment"><input type="checkbox"><span>[% c %]</span></span></span>'], '']);

package/src/parser/inline/extension/placeholder.ts

@@ -3,25 +3,25 @@ import { union, some, syntax, validate, surround, lazy } from '../../../combinat
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { Syntax, State } from '../../context';
-import { startTight } from '../../visibility';
+import { startTight, trimBlankEnd } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-// Don't use the symbols already used: !#$%@&*+~=
+// Don't use the symbols already used: !#$%@&*+~=|
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], surround(
-  str(/^\[[:^]/),
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', surround(
+  str(/^\[[:^|]/),
   syntax(Syntax.placeholder, 2, 1, State.none,
-  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]]))),
+  startTight(trimBlankEnd(some(union([inline]), ']', [[']', 2]])))),
   str(']'), false,
-  ([as, bs], rest) => [[
+  ([, bs], rest) => [[
     html('span', {
       class: 'invalid',
       'data-invalid-syntax': 'extension',
       'data-invalid-type': 'syntax',
-      'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
+      'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
   ([as, bs], rest) => [unshift(as, bs), rest])));

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

@@ -34,7 +34,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdi><wbr></bdi>')), [['<span class="invalid">&lt;bdi&gt;<wbr>&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>\n</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>a&lt;/bdi&gt;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<span class="linebreak"> </span>a&lt;/bdi&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>\\\na</bdi>')), [['<span class="invalid">&lt;bdi&gt;<br>a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a')), [['<span class="invalid">&lt;bdi&gt;a</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a</BDO>')), [['<span class="invalid">&lt;bdi&gt;a&lt;/BDO&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<BDI>a</BDI>')), [['<span class="invalid">&lt;BDI&gt;a&lt;/BDI&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -5,7 +5,7 @@ import { str } from '../source';
 import { Syntax, State } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
-import { Cache } from 'spica/cache';
+import { Clock } from 'spica/clock';
 import { unshift, push, splice } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
@@ -59,7 +59,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         ([as, bs = []], rest) =>
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
-    new Cache(10000))),
+    new Clock(10000))),
 ])))));
 
 export const attribute: HTMLParser.AttributeParser = union([

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

@@ -23,7 +23,7 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++ a ++')), [['<ins> a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++  a  ++')), [['<ins>  a  </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na++')), [['<ins><br>a</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++\\\na++')), [['<ins><span class="linebreak"> </span>a</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++\\\na++')), [['<ins><br>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++<wbr>a++')), [['<ins><wbr>a</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a \n ++')), [['<ins>a </ins>'], '']);
@@ -31,7 +31,7 @@ describe('Unit: parser/inline/insertion', () => {
       assert.deepStrictEqual(inspect(parser('++a\n ++')), [['<ins>a </ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\n<wbr>++')), [['<ins>a<wbr></ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a\nb++')), [['<ins>a<br>b</ins>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<span class="linebreak"> </span>b</ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a\\\nb++')), [['<ins>a<br>b</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++\\+++')), [['<ins>+</ins>'], '']);
       assert.deepStrictEqual(inspect(parser('++a+++')), [['<ins>a</ins>'], '+']);
     });

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

@@ -32,11 +32,11 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[mailto:á]{http://evil}')), undefined);
       assert.deepStrictEqual(inspect(parser('[file:///]{http://evil}')), undefined);
       assert.deepStrictEqual(inspect(parser('[.http://á]{http://evil}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[0987654321]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[1234567890-]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[-1234567890]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[123456789a]{tel:1234567890}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:ttel:1234567890}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[0987654321]{tel:1234567890}')), [['<a class="invalid">0987654321</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890-]{tel:1234567890}')), [['<a class="invalid">1234567890-</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[-1234567890]{tel:1234567890}')), [['<a class="invalid">-1234567890</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[123456789a]{tel:1234567890}')), [['<a class="invalid">123456789a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:ttel:1234567890}')), [['<a class="invalid">1234567890</a>'], '']);
       //assert.deepStrictEqual(inspect(parser('[#a]{b}')), undefined);
       //assert.deepStrictEqual(inspect(parser('[\\#a]{b}')), undefined);
       //assert.deepStrictEqual(inspect(parser('[c #a]{b}')), undefined);
@@ -145,6 +145,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('{tel:+1234567890}')), [[`<a class="tel" href="tel:+1234567890">tel:+1234567890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('{tel:+12-345-67-890}')), [[`<a class="tel" href="tel:+12-345-67-890">tel:+12-345-67-890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[1234567890]{tel:1234567890}')), [[`<a class="tel" href="tel:1234567890">1234567890</a>`], '']);
+      assert.deepStrictEqual(inspect(parser('[1234567890]{tel:12-3456-7890}')), [[`<a class="tel" href="tel:12-3456-7890">1234567890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[12-3456-7890]{tel:1234567890}')), [[`<a class="tel" href="tel:1234567890">12-3456-7890</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[+12-34567-890]{tel:+12-345-67890}')), [[`<a class="tel" href="tel:+12-345-67890">+12-34567-890</a>`], '']);
     });

package/src/parser/inline/link.ts

@@ -98,22 +98,6 @@ function parse(
   const uri = new ReadonlyURL(
     resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
     context.host?.href || location.href);
-  switch (uri.protocol) {
-    case 'tel:': {
-      const tel = content.length === 0
-        ? INSECURE_URI
-        : content[0];
-      const pattern = /^(?:tel:)?(?:\+(?!0))?\d+(?:-\d+)*$/i;
-      if (content.length <= 1 &&
-          typeof tel === 'string' &&
-          pattern.test(tel) &&
-          pattern.test(INSECURE_URI) &&
-          tel.replace(/[^+\d]/g, '') === INSECURE_URI.replace(/[^+\d]/g, '')) {
-        break;
-      }
-      return;
-    }
-  }
   const el = elem(
     INSECURE_URI,
     content,
@@ -135,35 +119,52 @@ function elem(
     case 'http:':
     case 'https:':
       assert(uri.host);
-      if (INSECURE_URI.slice(0, 2) === '^/' &&
-          /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/)))) {
-        type = 'argument';
-        message = 'Dot-segments cannot be used in subresource paths';
-        break;
+      switch (true) {
+        case INSECURE_URI.slice(0, 2) === '^/'
+          && /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/))):
+          type = 'argument';
+          message = 'Dot-segments cannot be used in subresource paths';
+          break;
+        default:
+          return html('a',
+            {
+              class: content.length === 0 ? 'url' : 'link',
+              href: uri.source,
+              target: undefined
+                || uri.origin !== origin
+                || typeof content[0] === 'object' && content[0].classList.contains('media')
+                  ? '_blank'
+                  : undefined,
+            },
+            content.length === 0
+              ? decode(INSECURE_URI)
+              : content);
       }
-      return html('a',
-        {
-          class: content.length === 0 ? 'url' : 'link',
-          href: uri.source,
-          target: undefined
-            || uri.origin !== origin
-            || typeof content[0] === 'object' && content[0].classList.contains('media')
-              ? '_blank'
-              : undefined,
-        },
-        content.length === 0
-          ? decode(INSECURE_URI)
-          : content);
+      break;
     case 'tel:':
       assert(content.length <= 1);
-      return html('a',
-        {
-          class: 'tel',
-          href: uri.source,
-        },
-        content.length === 0
-          ? [INSECURE_URI]
-          : content);
+      const tel = content.length === 0
+        ? INSECURE_URI
+        : content[0];
+      const pattern = /^(?:tel:)?(?:\+(?!0))?\d+(?:-\d+)*$/i;
+      switch (true) {
+        case content.length <= 1
+          && pattern.test(INSECURE_URI)
+          && typeof tel === 'string'
+          && pattern.test(tel)
+          && tel.replace(/[^+\d]/g, '') === INSECURE_URI.replace(/[^+\d]/g, ''):
+          return html('a',
+            {
+              class: 'tel',
+              href: uri.source,
+            },
+            content.length === 0
+              ? [INSECURE_URI]
+              : content);
+        default:
+          type = 'content';
+          message = 'Invalid content';
+      }
   }
   return html('a',
     {

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

@@ -15,8 +15,10 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('==a ==')), [['==', 'a'], ' ==']);
       assert.deepStrictEqual(inspect(parser('==a  ==')), [['==', 'a', ' '], ' ==']);
       assert.deepStrictEqual(inspect(parser('==a\n==')), [['==', 'a'], '\n==']);
+      assert.deepStrictEqual(inspect(parser('==a\nb==')), [['==', 'a'], '\nb==']);
       assert.deepStrictEqual(inspect(parser('==a\\ ==')), [['==', 'a'], '\\ ==']);
       assert.deepStrictEqual(inspect(parser('==a\\\n==')), [['==', 'a'], '\\\n==']);
+      assert.deepStrictEqual(inspect(parser('==a\\\nb==')), [['==', 'a'], '\\\nb==']);
       assert.deepStrictEqual(inspect(parser('== ==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a ==')), undefined);
@@ -27,20 +29,18 @@ describe('Unit: parser/inline/mark', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('==a==')), [['<mark>a</mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark>a=b</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 id="mark:a">a</mark>', '<a href="#mark:a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark id="mark:a=b">a=b</mark>', '<a href="#mark:a=b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark id="mark:=">=</mark>', '<a href="#mark:="></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a===')), [['<mark id="mark:a">a</mark>', '<a href="#mark:a"></a>'], '=']);
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark>a <mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark>a\t<mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark>a<wbr><mark>b</mark></mark>'], '']);
-      assert.deepStrictEqual(inspect(parser('==_==a==_==')), [['<mark><em><mark>a</mark></em></mark>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a ==b====')), [['<mark id="mark:a_b">a <mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\ ==b====')), [['<mark id="mark:a_b">a <mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a&Tab;==b====')), [['<mark id="mark:a_b">a\t<mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a<wbr>==b====')), [['<mark id="mark:ab">a<wbr><mark id="mark:b">b</mark><a href="#mark:b"></a></mark>', '<a href="#mark:ab"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==_==a==_==')), [['<mark id="mark:a"><em><mark id="mark:a">a</mark><a href="#mark:a"></a></em></mark>', '<a href="#mark:a"></a>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -1,19 +1,25 @@
 import { MarkParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { identity, text } from './extension/indexee';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
 import { Syntax, State } from '../context';
 import { unshift } from 'spica/array';
-import { html, defrag } from 'typed-dom/dom';
+import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() => surround(
   str('==', '='),
+  constraint(State.mark, false,
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('==')),
-    open(some(inline, '='), mark),
-  ])))),
+    some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
+    open(some(inline, '=', [[/^\\?\n/, 9]]), mark),
+  ]))))),
   str('=='), false,
-  ([, bs], rest) => [[html('mark', defrag(bs))], rest],
+  ([, bs], rest, { id }) => {
+    const el = html('mark', defrag(bs));
+    define(el, { id: id !== '' && identity(text(el), 'mark') || undefined });
+    return [[el, html('a', { href: el.id ? `#${el.id}` : undefined })], rest];
+  },
   ([as, bs], rest) => [unshift(as, bs), rest]));

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

@@ -12,8 +12,10 @@ describe('Unit: parser/inline/strong', () => {
       assert.deepStrictEqual(inspect(parser('*a *')), [['*', 'a'], ' *']);
       assert.deepStrictEqual(inspect(parser('*a  *')), [['*', 'a', ' '], ' *']);
       assert.deepStrictEqual(inspect(parser('*a\n*')), [['*', 'a'], '\n*']);
+      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['*', 'a'], '\nb*']);
       assert.deepStrictEqual(inspect(parser('*a\\ *')), [['*', 'a'], '\\ *']);
       assert.deepStrictEqual(inspect(parser('*a\\\n*')), [['*', 'a'], '\\\n*']);
+      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['*', 'a'], '\\\nb*']);
       assert.deepStrictEqual(inspect(parser('* *')), undefined);
       assert.deepStrictEqual(inspect(parser('* a*')), undefined);
       assert.deepStrictEqual(inspect(parser('* a *')), undefined);
@@ -28,8 +30,6 @@ describe('Unit: parser/inline/strong', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('*a*')), [['<strong>a</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>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/strong.ts

@@ -11,8 +11,8 @@ export const strong: StrongParser = lazy(() => surround(
   str('*', '*'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), strong),
+    some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
+    open(some(inline, '*', [[/^\\?\n/, 9]]), strong),
   ])))),
   str('*'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],

package/src/parser/inline.test.ts

@@ -51,7 +51,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[]{{a}}')), [['[', ']', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{{a}}')), [['!', '[', ']', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[\n]{a}')), [['[', '<br>', ']', '<a class="url" href="a">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[\\\n]{a}')), [['[', '<span class="linebreak"> </span>', ']', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[\\\n]{a}')), [['[', '<br>', ']', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{}')), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a}')), [['<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
@@ -81,6 +81,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[', '', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
@@ -89,11 +90,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<strong>b<br>c</strong>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<strong>a<br>b</strong>', ']', '<a class="url" href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<strong>a<br>b</strong>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a++b\nc++]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<ins>b<br>c</ins>', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[++a\nb++]{/}')), [['[', '<ins>a<br>b</ins>', ']', '<a class="url" href="/">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[++a\nb]++')), [['[', '++', 'a', '<br>', 'b', ']', '++'], '']);
+      assert.deepStrictEqual(inspect(parser('[++[a\nb++]')), [['', '[', '++', '[', 'a', '<br>', 'b', '++', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[++a\nb++]]')), [['[', '[', '<ins>a<br>b</ins>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });
@@ -158,7 +159,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('0aあい#b')), [['0a', 'あ', 'い#b'], '']);
       assert.deepStrictEqual(inspect(parser('「#あ」')), [['「', '<a class="hashtag" href="/hashtags/あ">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<span class="linebreak"> </span>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_a_#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<strong>a</strong>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);

package/src/parser/source/escapable.test.ts

@@ -39,7 +39,7 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\$')), [['\\$'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
     });
 
   });

package/src/parser/source/escapable.ts

@@ -15,7 +15,13 @@ export const escsource: EscapableSourceParser = creation(1, false, ({ source })
         case '\x1B':
           return [[source.slice(1, 2)], source.slice(2)];
         case '\\':
-          return [[source.slice(0, 2)], source.slice(2)];
+          switch (source[1]) {
+            case undefined:
+            case '\n':
+              return [[source[0]], source.slice(1)];
+            default:
+              return [[source.slice(0, 2)], source.slice(2)];
+          }
         default:
           const b = source[0] !== '\n' && source[0].trimStart() === '';
           const i = b

package/src/parser/source/text.test.ts

@@ -18,14 +18,28 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a\nb')), [['a', '<br>', 'b'], '']);
     });
 
+    it('escape', () => {
+      assert.deepStrictEqual(inspect(parser('\\')), [[], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\\\')), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\ ')), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser('\\_')), [['_'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0')), [['0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\a')), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\　')), [['　'], '']);
+      assert.deepStrictEqual(inspect(parser('\\。')), [['。'], '']);
+    });
+
     it('space', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [[], '']);
       assert.deepStrictEqual(inspect(parser(' \n')), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser('  \n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n')), [['<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser(' \\\n')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \\\n')), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser(' a')), [[' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('  a')), [[' ', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('   a')), [['  ', ' ', 'a'], '']);
@@ -33,8 +47,8 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a  ')), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('a \n')), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a  \n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a b')), [['a', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('a  b')), [['a', ' ', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('a   b')), [['a', '  ', ' ', 'b'], '']);
@@ -51,27 +65,13 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('。\n')), [['。', '<br>'], '']);
     });
 
-    it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\\')), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_')), [['_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0')), [['0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\a')), [['\\', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　')), [['　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\。')), [['。'], '']);
-    });
-
     it('softbreak', () => {
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n ')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\na')), [['<span class="linebreak"> </span>', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n')), [['a', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n')), [['a', '<span class="linebreak"> </span>', 'b', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\n')), [['\\', '<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n ')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\na')), [['<br>', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\n')), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n')), [['a', '<br>', 'b', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\\n')), [['\\', '<br>'], '']);
     });
 
     it('account', () => {
@@ -116,17 +116,6 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('>>>>0')), [['>', '>', '>', '>', '0'], '']);
     });
 
-    it('localize', () => {
-      assert.deepStrictEqual(inspect(parser('a\\\n0')), [['a', '<span class="linebreak"> </span>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('ア\\\n０')), [['ア', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('亜\\\n０')), [['亜', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('、\\\n０')), [['、', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('。\\\n０')), [['。', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('！？\\\n０')), [['！', '？', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('\\あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
-    });
-
   });
 
 });

package/src/parser/source/text.ts

@@ -3,10 +3,9 @@ import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+export const delimiter = /[\s\x00-\x7F]|\S[#>]/u;
 export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
-const nssb = /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creation(1, false, ({ source, context }) => {
@@ -16,26 +15,14 @@ export const text: TextParser = creation(1, false, ({ source, context }) => {
     case -1:
       return [[source], ''];
     case 0:
-      switch (source[0]) {
-        case '\x1B':
-        case '\\':
-          if (!nssb.test(source.slice(1))) break;
-          assert(source[0] !== '\x1B');
-          return text({ source: source.slice(1), context });
-        default:
-          const i = source.match(nssb)?.[0].length ?? -1;
-          if (i !== -1) return [[source[0], html('span', { class: 'linebreak' })], source.slice(i + 2)];
-      }
       switch (source[0]) {
         case '\x1B':
         case '\\':
           switch (source[1]) {
             case undefined:
-              assert(source[0] !== '\x1B');
-              return [[], ''];
             case '\n':
               assert(source[0] !== '\x1B');
-              return [[html('span', { class: 'linebreak' }, ' ')], source.slice(2)];
+              return [[], source.slice(1)];
             default:
               return [[source.slice(1, 2)], source.slice(2)];
           }

package/src/parser/visibility.ts

@@ -108,10 +108,7 @@ export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boo
   for (let i = 0; i < nodes.length; ++i) {
     const node = nodes[i];
     if (isVisible(node)) return true;
-    if (typeof node === 'object') {
-      if (node.tagName === 'BR') break;
-      if (node.className === 'linebreak') break;
-    }
+    if (typeof node === 'object' && node.tagName === 'BR') break;
   }
   return false;
 }
@@ -143,8 +140,6 @@ function isVisible(node: HTMLElement | string, strpos?: number): boolean {
         case 'BR':
         case 'WBR':
           return false;
-        case 'SPAN':
-          return node.className !== 'linebreak';
         default:
           return true;
       }