securemark 0.217.0 → 0.218.3

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

@@ -27,19 +27,13 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{ }')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{  }')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{   }')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{/  }')), [['<a href="/" target="_blank"><img class="media invalid" data-src="/" alt=""></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{/ /}')), [['<a href="/" target="_blank"><img class="media invalid" data-src="/" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]]{/}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{a}}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{a  }')), [['<a href="a" target="_blank"><img class="media invalid" data-src="a" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{a\nb}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{a\\\nb}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ a}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{ a  }')), [['<a href="a" target="_blank"><img class="media invalid" data-src="a" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{ a\n}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{\ta }')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{\ta\t}')), undefined);
       assert.deepStrictEqual(inspect(parser('![ ]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![  ]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![\\ ]{#}')), undefined);
@@ -48,7 +42,6 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![ a]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![ a ]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![\\ a ]{#}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![a  ]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\nb]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\\\nb]{#}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="media invalid" data-src="ttp://host" alt="">'], '']);
@@ -62,13 +55,16 @@ describe('Unit: parser/inline/media', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('![]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{ b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{ b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\ }')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\b}')), [['<a href="\\b" target="_blank"><img class="media" data-src="\\b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{./b}')), [['<a href="./b" target="_blank"><img class="media" data-src="./b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{^/b}')), [[`<a href="/b" target="_blank"><img class="media" data-src="/b" alt=""></a>`], '']);
       assert.deepStrictEqual(inspect(parser('![a ]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![a  ]{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![a b]{c}')), [['<a href="c" target="_blank"><img class="media" data-src="c" alt="a b"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('!{b}')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('!{ ][ }')), [['<a href="][" target="_blank"><img class="media" data-src="][" alt=""></a>'], '']);

package/src/parser/inline/media.ts

@@ -6,7 +6,7 @@ import { link, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { htmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { isStartTight, isEndTight } from '../util';
+import { verifyStartTight } from '../util';
 import { html, define } from 'typed-dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push, join } from 'spica/array';
@@ -25,10 +25,10 @@ export const media: MediaParser = lazy(() => creator(10, bind(verify(fmap(open(
   guard(context => context.syntax?.inline?.media ?? true,
   tails([
     dup(surround(/^\[(?!\\?\s)/, some(union([htmlentity, bracket, txt]), ']', /^\\?\n/), ']', true)),
-    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^ ?}/)),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]?}/)),
   ])))),
   ([as, bs]) => bs ? [[join(as)], bs] : [[''], as]),
-  ([[text]]) => isStartTight([text || '-']) && isEndTight([text])),
+  ([[text]]) => verifyStartTight([text || '-'])),
   ([[text], params], rest, context) => {
     const INSECURE_URI = params.shift()!;
     assert(INSECURE_URI === INSECURE_URI.trim());
@@ -60,8 +60,8 @@ const bracket: MediaParser.TextParser.BracketParser = lazy(() => union([
 ]));
 
 const option: MediaParser.ParameterParser.OptionParser = union([
-  fmap(str(/^ [1-9][0-9]*x[1-9][0-9]*(?=[ }])/), ([opt]) => [` width="${opt.slice(1).split('x')[0]}"`, ` height="${opt.slice(1).split('x')[1]}"`]),
-  fmap(str(/^ [1-9][0-9]*:[1-9][0-9]*(?=[ }])/), ([opt]) => [` aspect-ratio="${opt.slice(1).split(':').join('/')}"`]),
+  fmap(str(/^[^\S\n]+[1-9][0-9]*x[1-9][0-9]*(?=[^\S\n]|})/), ([opt]) => [` width="${opt.slice(1).split('x')[0]}"`, ` height="${opt.slice(1).split('x')[1]}"`]),
+  fmap(str(/^[^\S\n]+[1-9][0-9]*:[1-9][0-9]*(?=[^\S\n]|})/), ([opt]) => [` aspect-ratio="${opt.slice(1).split(':').join('/')}"`]),
   linkoption,
 ]);
 

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

@@ -20,11 +20,6 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[\na]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\ a]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\\na]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a  ]]')), 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\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[a\nb]]')), undefined);
@@ -40,7 +35,11 @@ describe('Unit: parser/inline/reference', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('[[a]]')), [['<sup class="reference">a</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[a ]]')), [['<sup class="reference">a </sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a ]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a  ]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a &nbsp;]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a <wbr>]]')), [['<sup class="reference">a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[a [# b #]]]')), [['<sup class="reference">a <sup class="comment" title="b"></sup></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[ab]]')), [['<sup class="reference">ab</sup>'], '']);
     });
 
@@ -57,18 +56,28 @@ describe('Unit: parser/inline/reference', () => {
     it('abbr', () => {
       assert.deepStrictEqual(inspect(parser('[[^]]')), [['<sup class="reference invalid">^</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a,]]')), [['<sup class="reference" data-abbr="a,"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a, ]]')), [['<sup class="reference" data-abbr="a,"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a  ]]')), [['<sup class="reference invalid">^a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a b]]')), [['<sup class="reference" data-abbr="a b"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a  b]]')), [['<sup class="reference invalid">^a  b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a,|]]')), [['<sup class="reference" data-abbr="a,"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a |]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|b]]')), [['<sup class="reference invalid">^a|b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| b ]]')), [['<sup class="reference" data-abbr="a">b </sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a| b ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a| b  ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|  ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|  b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a| <wbr>]]')), [['<sup class="reference invalid">^a|</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a| <wbr>b]]')), [['<sup class="reference invalid">^a| <wbr>b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a| ^b]]')), [['<sup class="reference" data-abbr="a">^b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1]]')), [['<sup class="reference invalid">^1</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1a]]')), [['<sup class="reference" data-abbr="1a"></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^1 ]]')), [['<sup class="reference invalid">^1 </sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^1 ]]')), [['<sup class="reference invalid">^1</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1 a]]')), [['<sup class="reference" data-abbr="1 a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1|]]')), [['<sup class="reference invalid">^1|</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1 |]]')), [['<sup class="reference invalid">^1 |</sup>'], '']);
@@ -76,9 +85,15 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^Xyz 2020]]')), [['<sup class="reference" data-abbr="Xyz 2020"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^Xyz, 2020, p1-2]]')), [['<sup class="reference" data-abbr="Xyz, 2020, p1-2"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^X. Y., Z et al., 2020, p1-2]]')), [['<sup class="reference" data-abbr="X. Y., Z et al., 2020, p1-2"></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser(`[[^A's, Aces']]`)), [[`<sup class="reference" data-abbr="A's, Aces'"></sup>`], '']);
       assert.deepStrictEqual(inspect(parser('[[^^]]')), [['<sup class="reference invalid">^^</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[\\^]]')), [['<sup class="reference">^</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| ^b]]')), [['<sup class="reference" data-abbr="a">^b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ ]]')), [['<sup class="reference invalid">^</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ a]]')), [['<sup class="reference invalid">^ a</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ |]]')), [['<sup class="reference invalid">^ |</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ |b]]')), [['<sup class="reference invalid">^ |b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ | ]]')), [['<sup class="reference invalid">^ |</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^ | b]]')), [['<sup class="reference invalid">^ | b</sup>'], '']);
     });
 
   });

package/src/parser/inline/reference.ts

@@ -3,10 +3,10 @@ import { ReferenceParser } from '../inline';
 import { union, subsequence, some, validate, verify, focus, guard, context, creator, surround, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { startTight, isEndTight, stringify } from '../util';
+import { startTight, isStartTight, trimEnd, stringify } from '../util';
 import { html, defrag } from 'typed-dom';
 
-export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(verify(surround(
+export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]', '\n', fmap(surround(
   '[[',
   guard(context => context.syntax?.inline?.reference ?? true,
   startTight(
@@ -23,23 +23,23 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
   subsequence([
     abbr,
     focus('^', c => [['', c], '']),
-    startTight(some(inline, ']', /^\\?\n/)),
+    some(inline, ']', /^\\?\n/),
   ])))),
   ']]'),
-  isEndTight),
-  ns => [html('sup', attributes(ns), defrag(ns))]))));
+  ns => [html('sup', attributes(ns), trimEnd(defrag(ns)))]))));
 
-const abbr: ReferenceParser.AbbrParser = creator(fmap(surround(
+const abbr: ReferenceParser.AbbrParser = creator(fmap(verify(surround(
   '^',
-  union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:['-]|[.,]? |\., )[0-9A-Za-z]+)*/)]),
-  /^[^\S\n]?\|?(?=]])|^\|[^\S\n]/),
+  union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
+  /^\|?(?=]])|^\|[^\S\n]+/),
+  (_, rest, context) => isStartTight(rest, context)),
   ([source]) => [html('abbr', source)]));
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   return typeof ns[0] === 'object' && ns[0].tagName === 'ABBR'
     ? {
         class: 'reference',
-        'data-abbr': stringify([ns.shift()!]),
+        'data-abbr': stringify([ns.shift()!]).trimEnd(),
       }
     : ns[0] === ''
       ? {

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

@@ -16,7 +16,6 @@ describe('Unit: parser/inline/ruby', () => {
       assert.deepStrictEqual(inspect(parser('[	 a](b)')), undefined);
       assert.deepStrictEqual(inspect(parser('[a]()')), undefined);
       assert.deepStrictEqual(inspect(parser('[a]( )')), undefined);
-      assert.deepStrictEqual(inspect(parser('[a  ](b)')), undefined);
       assert.deepStrictEqual(inspect(parser('[a\nb](c)')), undefined);
       assert.deepStrictEqual(inspect(parser('[a](b\nc)')), undefined);
       assert.deepStrictEqual(inspect(parser(' [a](b)')), undefined);
@@ -29,6 +28,8 @@ describe('Unit: parser/inline/ruby', () => {
       assert.deepStrictEqual(inspect(parser('[A ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser('[A ](a b)')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser('[A ](a b )')), [['<ruby>A<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A  ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp><rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser('[A \\ ](a)')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp> <rt></rt></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser('[AB](a)')), [['<ruby>AB<rp>(</rp><rt>a</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser('[AB](a )')), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser('[AB]( b)')), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);

package/src/parser/inline/ruby.ts

@@ -4,7 +4,7 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, validate, verify, focus, creator, surround, lazy, bind } from '../../combinator';
 import { htmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { isStartTight, isEndTight } from '../util';
+import { verifyStartTight } from '../util';
 import { html, defrag } from 'typed-dom';
 import { unshift, push, join } from 'spica/array';
 
@@ -14,32 +14,34 @@ export const ruby: RubyParser = lazy(() => creator(bind(verify(
     surround('[', focus(/^(?:\\[^\n]|[^\[\]\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\(\)\n])+(?=\))/, text), ')'),
   ])),
-  ([texts]) => isStartTight(texts) && isEndTight(texts)),
+  ([texts]) => verifyStartTight(texts)),
   ([texts, rubies], rest) => {
-    texts[texts.length - 1] || texts.pop();
-    assert(texts[texts.length - 1].trim());
+    const tail = typeof texts[texts.length - 1] === 'object'
+      ? [texts.pop()!]
+      : [];
+    tail.length === 0 && texts[texts.length - 1] === '' && texts.pop();
     switch (true) {
       case rubies.length <= texts.length:
-        return [[html('ruby', defrag(texts
+        return [[html('ruby', defrag(push(texts
           .reduce((acc, _, i) =>
             push(acc, unshift([texts[i]],
               i < rubies.length && rubies[i]
                 ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                 : [html('rt')]))
-          , [])))], rest];
+          , []), tail)))], rest];
       case texts.length === 1 && [...texts[0]].length >= rubies.length:
-        return [[html('ruby', defrag([...texts[0]]
+        return [[html('ruby', defrag(push([...texts[0]]
           .reduce((acc, _, i, texts) =>
             push(acc, unshift([texts[i]],
               i < rubies.length && rubies[i]
                 ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                 : [html('rt')]))
-          , [])))], rest];
+          , []), tail)))], rest];
       default:
         assert(rubies.length > 0);
-        return [[html('ruby', defrag(unshift(
+        return [[html('ruby', defrag(push(unshift(
           [join(texts, ' ')],
-          [html('rp', '('), html('rt', join(rubies, ' ').trim()), html('rp', ')')])))
+          [html('rp', '('), html('rt', join(rubies, ' ').trim()), html('rp', ')')]), tail)))
         ], rest];
     }
   })));

package/src/parser/inline/strong.ts

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

package/src/parser/segment.ts

@@ -10,20 +10,20 @@ import { contentline, emptyline } from './source';
 
 import SegmentParser = MarkdownParser.SegmentParser;
 
-const INPUT_SIZE_LIMIT = 1000 ** 2;
-export const SEGMENT_LENGTH_LIMIT = 100 * 1000;
+export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB)
+export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
 
 const parser: SegmentParser = union([
   heading,
   codeblock,
   mathblock,
   extension,
-  some(contentline, SEGMENT_LENGTH_LIMIT),
-  some(emptyline, SEGMENT_LENGTH_LIMIT),
+  some(contentline, MAX_SEGMENT_SIZE * 2),
+  some(emptyline, MAX_SEGMENT_SIZE * 2),
 ]);
 
 export function* segment(source: string): Generator<string, undefined, undefined> {
-  if (!validate(source)) return yield `\0Too large input over ${INPUT_SIZE_LIMIT.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;
+  if (!validate(source, MAX_INPUT_SIZE)) return yield `\0Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;
   assert(source.length < Number.MAX_SAFE_INTEGER);
   while (source !== '') {
     const result = parser(source, {})!;
@@ -34,21 +34,15 @@ export function* segment(source: string): Generator<string, undefined, undefined
     assert(segs.join('') === source.slice(0, source.length - rest.length));
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
-      seg.length > SEGMENT_LENGTH_LIMIT
-        ? yield `\0Too large segment over ${SEGMENT_LENGTH_LIMIT.toLocaleString('en')} in length.\n${seg}`
-        : yield seg;
+      validate(source, MAX_SEGMENT_SIZE)
+        ? yield seg
+        : yield `\0Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`
     }
     source = rest;
   }
 }
 
-function validate(source: string): boolean {
-  return source.length <= INPUT_SIZE_LIMIT
-      && new Blob([source]).size <= INPUT_SIZE_LIMIT;
-}
-
-export function prepare(source: string): string {
-  return validate(source)
-    ? source
-    : source.slice(0, INPUT_SIZE_LIMIT + 1);
+export function validate(source: string, size: number): boolean {
+  return source.length <= size / 2
+      || source.length <= size && new Blob([source]).size <= size;
 }

package/src/parser/source/escapable.ts

@@ -4,6 +4,7 @@ import { creator } from '../../combinator';
 const separator = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
 export const escsource: EscapableSourceParser = creator(source => {
+  assert(source[0] !== '\x7F');
   if (source === '') return;
   const i = source.search(separator);
   switch (i) {

package/src/parser/source/str.ts

@@ -3,22 +3,20 @@ import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creator } from '../../combinator';
 
-export function str(pattern: string | RegExp, not?: string): StrParser;
-export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
+export function str(pattern: string | RegExp, mustConsume?: boolean): StrParser;
+export function str(pattern: string | RegExp, mustConsume = true): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
     ? creator(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
-            && !(not && source.slice(pattern.length, pattern.length + not.length) === not)
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
     : creator(source => {
         if (source === '') return;
         const m = source.match(pattern);
-        return m && m[0].length > 0
-            && !(not && source.slice(m[0].length, m[0].length + not.length) === not)
+        return m && (!mustConsume || m[0].length > 0)
           ? [[m[0]], source.slice(m[0].length)]
           : undefined;
       });

package/src/parser/source/text.ts

@@ -1,7 +1,6 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { Parser, Context } from '../../combinator/data/parser';
-import { union, focus, creator, fmap } from '../../combinator';
+import { union, focus, creator } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom';
 
@@ -18,6 +17,9 @@ export const text: TextParser = creator((source, context) => {
       return [[source], ''];
     case 0:
       switch (source[0]) {
+        case '\x7F':
+          assert(source[1] === '\\');
+          return [[], source.slice(1)];
         case '\\':
           switch (source[1]) {
             case undefined:
@@ -66,11 +68,11 @@ export const text: TextParser = creator((source, context) => {
 
 export const txt: TxtParser = union([
   text,
-]) as Parser<string, Context<TxtParser>, [TextParser]>;
+]) as TxtParser;
 
-export const linebreak: LinebreakParser = fmap(
-  focus('\n', union([text])),
-  ns => ns as [HTMLBRElement]);
+export const linebreak: LinebreakParser = focus('\n', union([
+  text,
+])) as LinebreakParser;
 
 export function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);

package/src/parser/source/unescapable.ts

@@ -3,6 +3,7 @@ import { creator } from '../../combinator';
 import { separator, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 
 export const unescsource: UnescapableSourceParser = creator(source => {
+  assert(source[0] !== '\x7F');
   if (source === '') return;
   const i = source.search(separator);
   switch (i) {

package/src/parser/util.ts

@@ -1,10 +1,11 @@
 import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
 import { Parser, eval } from '../combinator/data/parser';
-import { union, verify, convert } from '../combinator';
+import { union, some, verify, clear, convert, trim } from '../combinator';
 import { comment } from './inline/comment';
 import { htmlentity } from './inline/htmlentity';
-import { pop } from 'spica/array';
+import { linebreak, unescsource, str } from './source';
+import { push, pop } from 'spica/array';
 
 // https://dev.w3.org/html5/html-author/charref
 const invisibleHTMLEntityNames = [
@@ -41,22 +42,20 @@ const invisibleHTMLEntityNames = [
   'InvisibleComma',
   'ic',
 ];
-const blankline = new RegExp(String.raw`^(?!\n|$)(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});)*\\?(?:\n|$)`, 'gm');
+const blankline = new RegExp(String.raw`^(?!\n|$)(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)*\\?(?:\n|$)`, 'gm');
 
-export function visualize<P extends Parser<HTMLElement | string>>(parser: P, message?: string): P;
-export function visualize<T extends HTMLElement | string>(parser: Parser<T>, message = '(Empty)'): Parser<T> {
+export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
+export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
   return justify(union([
     verify(parser, (ns, rest, context) => !rest && hasVisible(ns, context)),
-    (source: string) => [[source.trim() || message], ''],
+    trim(some(union([clear(str('\x7F\\')), linebreak, unescsource]))),
   ]));
 }
 function justify<P extends Parser<unknown>>(parser: P): P;
 function justify<T>(parser: Parser<T>): Parser<T> {
-  return convert(source => source.replace(blankline, visualize), parser);
-
-  function visualize(line: string): string {
-    return line.replace(/[\\&]/g, '\\$&');
-  }
+  return convert(
+    source => source.replace(blankline, line => line.replace(/[\\&<]/g, '\x7F\\$&')),
+    parser);
 }
 function hasVisible(
   nodes: readonly (HTMLElement | string)[],
@@ -77,70 +76,71 @@ function hasVisible(
 
 export function startTight<P extends Parser<unknown>>(parser: P): P;
 export function startTight<T>(parser: Parser<T>): Parser<T> {
-  return (source, context) => {
-    if (source === '') return;
-    switch (source[0]) {
-      case ' ':
-      case '　':
-      case '\t':
-      case '\n':
-        return;
-      case '&':
-        switch (true) {
-          case source.length > 2
-            && source[1] !== ' '
-            && eval(htmlentity(source, context))?.[0].trimStart() == '':
-            return;
-        }
-        break;
-      case '[':
-        switch (true) {
-          case source.length >= 7
-            && source[1] === '#'
-            && !!comment(source, context):
-            return;
-        }
-        break;
-      case '<':
-        switch (true) {
-          case source.length >= 5
-            && source[1] === 'w'
-            && source.slice(0, 5) === '<wbr>':
-          case source.length >= 4
-            && source[1] === 'b'
-            && source.slice(0, 4) === '<br>':
-            return;
-        }
-        break;
-    }
-    return (source[0] === '\\' ? source[1] : source[0])?.trimStart()
+  return (source, context) =>
+    isStartTight(source, context)
       ? parser(source, context)
       : undefined;
-  }
 }
 
-export function isStartTight(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isStartTight(source: string, context: MarkdownParser.Context): boolean {
+  if (source === '') return true;
+  switch (source[0]) {
+    case ' ':
+    case '　':
+    case '\t':
+    case '\n':
+      return false;
+    case '\\':
+      return source[1]?.trimStart() !== '';
+    case '&':
+      switch (true) {
+        case source.length > 2
+          && source[1] !== ' '
+          && eval(htmlentity(source, context))?.[0].trimStart() == '':
+          return false;
+      }
+      return true;
+    case '<':
+      switch (true) {
+        case source.length >= 5
+          && source[1] === 'w'
+          && source.slice(0, 5) === '<wbr>':
+          return false;
+      }
+      return true;
+    case '[':
+      switch (true) {
+        case source.length >= 7
+          && source[1] === '#'
+          && !!comment(source, context):
+          return false;
+      }
+      return true;
+    default:
+      return source[0].trimStart() !== '';
+  }
+}
+export function verifyStartTight(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
-  return isVisible(nodes[0], 'start');
+  return isVisible(nodes[0]);
 }
-export function isEndTight(nodes: readonly (HTMLElement | string)[]): boolean {
+export function verifyEndTight(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], 'end', 0) ||
-      isVisible(nodes[last], 'end', 1)
-    : isVisible(nodes[last], 'end') || last === 0 ||
-      isVisible(nodes[last - 1], 'end');
+    ? isVisible(nodes[last], -1) ||
+      isVisible(nodes[last], -2)
+    : isVisible(nodes[last], -1) || last === 0 ||
+      isVisible(nodes[last - 1], -1);
 }
-function isVisible(node: HTMLElement | string | undefined, dir: 'start' | 'end', offset = 0): boolean {
-  assert(offset >= 0);
+function isVisible(node: HTMLElement | string, position = 0): boolean {
   if (!node) return false;
   switch (typeof node) {
     case 'string':
-      const char = node[dir === 'start' ? 0 + offset : node.length - 1 - offset];
+      assert(node.length + position >= 0);
+      const char = node[position >= 0 ? position : node.length + position];
       assert(char);
       switch (char) {
-        case '':
         case ' ':
         case '\t':
         case '\n':
@@ -163,6 +163,31 @@ function isVisible(node: HTMLElement | string | undefined, dir: 'start' | 'end',
   }
 }
 
+export function trimEnd(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
+  assert(verifyStartTight(nodes));
+  const skip = nodes.length > 0 &&
+    typeof nodes[nodes.length - 1] === 'object' &&
+    nodes[nodes.length - 1]['className'] === 'indexer'
+    ? [nodes.pop()!]
+    : [];
+  for (
+    let last = nodes[0];
+    nodes.length > 0 &&
+    !isVisible(last = nodes[nodes.length - 1], -1) &&
+    !(typeof last === 'object' && last.className === 'comment');
+  ) {
+    assert(nodes.length > 0);
+    if (typeof last === 'string') {
+      const pos = last.trimEnd().length;
+      if (pos > 0) {
+        nodes[nodes.length - 1] = last.slice(0, pos);
+        break;
+      }
+    }
+    nodes.pop();
+  }
+  return push(nodes, skip);
+}
 export function trimEndBR<T extends HTMLElement | string>(nodes: T[]): T[];
 export function trimEndBR(nodes: (HTMLElement | string)[]): (HTMLElement | string)[] {
   if (nodes.length === 0) return nodes;