securemark 0.295.9 → 0.296.1

package/src/combinator/data/parser.ts

@@ -69,6 +69,8 @@ export class Context {
   // Objectの内部実装を利用する。
   // 探索木を直接使用する場合は探索速度が重要で挿入は相対的に少なく削除は不要かつ不確実であるため
   // AVL木が適当と思われる。
+  // メモリの局所性を得るために木ごとに最初の数十から数百byte分のノードをプールしノードが不足した場合は
+  // 使い捨てノードを追加またはテーブルに移行するとよいだろう。
   // 最大セグメントサイズ10KB内で探索コストが平均実行性能を圧迫するほど大きくなるとは考えにくいが
   // 探索コストを減らすにはバックトラック位置数が規定数を超えた場合一定区間ごとに探索木を分割する方法が考えられる。
   // 10KBの入力すべてを保持する探索木を1024文字ごとに分割するために必要なテーブルサイズは64bit*98=784byteとなる。

package/src/parser/api/normalize.ts

@@ -1,6 +1,4 @@
-import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
-import { unsafehtmlentity } from '../inline/htmlentity';
+import { html } from 'typed-dom/dom';
 
 const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
 assert(UNICODE_REPLACEMENT_CHARACTER.trim());
@@ -15,7 +13,7 @@ function format(source: string): string {
 
 const invalid = new RegExp([
   /(?![\t\r\n])[\x00-\x1F\x7F]/g.source,
-  /(?!\u200D)[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]/g.source,
+  /(?![\u200C\u200D])[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]/g.source,
   // 後読みが重い
   ///(?<![\u1820\u1821])\u180E/g.source,
   ///[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g.source,
@@ -26,7 +24,7 @@ function sanitize(source: string): string {
 
 // https://dev.w3.org/html5/html-author/charref
 // https://en.wikipedia.org/wiki/Whitespace_character
-export const invisibleHTMLEntityNames = [
+const invisibleHTMLEntityNames = [
   'Tab',
   'NewLine',
   'NonBreakingSpace',
@@ -60,6 +58,15 @@ export const invisibleHTMLEntityNames = [
   'InvisibleComma',
   'ic',
 ] as readonly string[];
+const parser = (el => (entity: string): string => {
+  if (entity === '&NewLine;') return entity;
+  el.innerHTML = entity;
+  return el.textContent!;
+})(html('span'));
+export const invisibleBlankHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
+  .filter(name => parser(`&${name};`).trimStart() === '');
+export const invisibleGraphHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
+  .filter(name => parser(`&${name};`).trimStart() !== '');
 const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name => ![
   'Tab',
   'NewLine',
@@ -69,7 +76,7 @@ const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name =>
   'zwnj',
 ].includes(name));
 const unreadableEscapeCharacters = unreadableEscapeHTMLEntityNames
-  .map(name => unsafehtmlentity(input(`&${name};`, new Context()))!.head!.value);
+  .map(name => parser(`&${name};`));
 assert(unreadableEscapeCharacters.length === unreadableEscapeHTMLEntityNames.length);
 assert(unreadableEscapeCharacters.every(c => c.length === 1));
 const unreadableEscapeCharacter = new RegExp(`[${unreadableEscapeCharacters.join('')}]`, 'g');
@@ -84,7 +91,7 @@ const unreadableSpecialCharacters = [
   // ZERO WIDTH SPACE
   '\u200B',
   // ZERO WIDTH NON-JOINER
-  '\u200C',
+  //'\u200C',
   // ZERO WIDTH JOINER
   //'\u200D',
   // LEFT-TO-RIGHT MARK

package/src/parser/block/reply/cite.ts

@@ -34,6 +34,6 @@ export const cite: ReplyParser.CiteParser = line(fmap(
             ? define(node, { 'data-depth': `${quotes.length + 1}` }, node.innerText.slice(1))
             : node.slice(1),
         ]))),
-      new Node(html('br'), Flag.invisible),
+      new Node(html('br'), Flag.blank),
     ]);
   }));

package/src/parser/block/reply/quote.ts

@@ -22,7 +22,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         unescsource,
       ])))),
   (ns, { source, position }) => new List([
-    new Node(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br'), Flag.invisible),
+    new Node(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br'), Flag.blank),
     new Node(html('span', { class: 'quote' }, defrag(unwrap(ns)))),
   ].reverse())),
   false));

package/src/parser/block/reply.ts

@@ -21,6 +21,6 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
       visualize(fmap(some(inline), (ns, { source, position }) =>
         source[position - 1] === '\n'
           ? ns
-          : ns.push(new Node(html('br'), Flag.invisible)) && ns)))
+          : ns.push(new Node(html('br'), Flag.blank)) && ns)))
   ])),
   ns => new List([new Node(html('p', defrag(unwrap(trimBlankNodeEnd(ns)))))]))));

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

@@ -19,7 +19,10 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('(([))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(([%))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(( ))', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('(( (a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((\\ a))', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('((<wbr>a))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\n))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\na))', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('((\\\na))', new Context())), undefined);
@@ -35,10 +38,6 @@ describe('Unit: parser/inline/annotation', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('(( a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('(( a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((\\ a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('((<wbr>a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((a  ))', new Context())), [['<sup class="annotation"><span>a</span></sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -3,14 +3,14 @@ import { State, Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, precedence, state, constraint, surround, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
   '((',
   precedence(1, state(State.annotation,
-  trimBlankStart(some(union([inline]), ')', [[')', 1]])))),
+  beforeNonblank(some(union([inline]), ')', [[')', 1]])))),
   '))',
   false,
   [2, 1 | Backtrack.common, 3 | Backtrack.doublebracket],

package/src/parser/inline/html.ts

@@ -5,7 +5,7 @@ import { Flag } from '../node';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { isLooseNodeStart, blankWith } from '../visibility';
+import { isNonblankFirstLine, blankWith } from '../visibility';
 import { invalid, unwrap } from '../util';
 import { memoize } from 'spica/memoize';
 import { html as h, defrag } from 'typed-dom/dom';
@@ -29,7 +29,7 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       open(str(/ ?/y), str('>'), true),
       true, [],
       ([as, bs = new List(), cs], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.invisible : Flag.none)]),
+        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
       ([as, bs = new List()], context) =>
         new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(
@@ -85,7 +85,7 @@ function elem(tag: string, content: boolean, as: readonly string[], bs: List<Nod
   if (content) {
     if (cs.length === 0) return ielem('tag', `Missing the closing HTML tag "</${tag}>"`, context);
     if (bs.length === 0) return ielem('content', `Missing the content`, context);
-    if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, context);
+    if (!isNonblankFirstLine(bs)) return ielem('content', `Missing the visible content in the same line`, context);
   }
   const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)

package/src/parser/inline/htmlentity.ts

@@ -1,7 +1,7 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { Backtrack } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { Flag, isinvisibleHTMLEntityName } from '../node';
+import { Flag, isBlankHTMLEntityName } from '../node';
 import { union, surround, fmap } from '../../combinator';
 import { str } from '../source';
 import { invalid } from '../util';
@@ -15,7 +15,7 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = surround(
     new List([
       new Node(
         parser(as.head!.value + bs.head!.value + cs.head!.value),
-        isinvisibleHTMLEntityName(bs.head!.value) ? Flag.invisible : Flag.none)
+        isBlankHTMLEntityName(bs.head!.value) ? Flag.blank : Flag.none)
     ]),
   ([as, bs]) =>
     new List([new Node(as.head!.value + (bs?.head?.value ?? ''))]));

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

@@ -76,6 +76,10 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[ ]{ }', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[  ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ a ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[\\ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[ \\ a]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\\ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[\\\n]{b}', new Context())), undefined);
@@ -131,10 +135,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.a0', location.origin) }))), [[`<a class="url" href="/b">^/b</a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.0', location.origin) }))), [[`<a class="url" href="/0.0/b">^/b</a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('[]{^/b}', new Context({ host: new URL('/0.0,0.0,0z', location.origin) }))), [[`<a class="url" href="/0.0,0.0,0z/b">^/b</a>`], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ a ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[\\ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[ \\ a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a  ]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[a]{b}', new Context())), [['<a class="link" href="b">a</a>'], '']);

package/src/parser/inline/link.ts

@@ -5,7 +5,7 @@ import { union, inits, sequence, subsequence, some, consume, precedence, state,
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
-import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap, invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -20,7 +20,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
     constraint(State.link, state(State.linkers, dup(surround(
       '[',
       precedence(1,
-      trimBlankStart(some(union([inline]), ']', [[']', 1]]))),
+      beforeNonblank(some(union([inline]), ']', [[']', 1]]))),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],

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

@@ -41,6 +41,10 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser, input('![ ]{}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![  ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ a ]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![\\ a]{b}', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('![ \\ a]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\n]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\\ ]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![\\\n]{b}', new Context())), undefined);
@@ -79,8 +83,6 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser, input('![]{?/../}', new Context())), [[`<a href="?/../" target="_blank"><img class="media" data-src="?/../" alt="?/../"></a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('![]{#/../}', new Context())), [[`<a href="#/../" target="_blank"><img class="media" data-src="#/../" alt="#/../"></a>`], '']);
       assert.deepStrictEqual(inspect(parser, input('![]{^/b}', new Context())), [[`<a href="/b" target="_blank"><img class="media" data-src="/b" alt="^/b"></a>`], '']);
-      assert.deepStrictEqual(inspect(parser, input('![ a]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('![ a ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a  ]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="a"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![a b]{c}', new Context())), [['<a href="c" target="_blank"><img class="media" data-src="c" alt="a b"></a>'], '']);

package/src/parser/inline/media.ts

@@ -1,6 +1,7 @@
 import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
+import { Flag } from '../node';
 import { union, inits, tails, some, consume, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { uri, option as linkoption, resolve, decode, parse } from './link';
 import { attributes } from './html';
@@ -50,10 +51,14 @@ export const media: MediaParser = lazy(() => constraint(State.media, open(
   nodes =>
     nodes.length === 1
       ? new List<Node<List<Node<string>>>>([new Node(new List([new Node('')])), nodes.delete(nodes.head!)])
-      : new List<Node<List<Node<string>>>>([new Node(new List([new Node(nodes.head!.value.foldl((acc, { value }) => acc + value, ''))])), nodes.delete(nodes.last!)])),
-  ([{ value: [{ value: text }] }, { value: params }], context) => {
-    if (text && text.trimStart() === '') return;
-    text = text.trim();
+      : new List<Node<List<Node<string>>>>([new Node(new List([new Node(nodes.head!.value.foldl((acc, { value }) => acc + value, ''), nodes.head!.value.head?.flags)])), nodes.delete(nodes.last!)])),
+  ([{ value: [{ value: text, flags }] }, { value: params }], context) => {
+    if (flags & Flag.blank) return;
+    if (text) {
+      const tmp = text;
+      text = text.trim();
+      if (text === '' || text[0] !== tmp[0]) return;
+    }
     consume(100, context);
     if (params.last!.value === Command.Cancel) {
       params.pop();

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

@@ -19,7 +19,10 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser, input('[[(]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[[%]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[ ]]', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[[ [a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[ a]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[ a ]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[\\ a]]', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('[[<wbr>a]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[\n]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[\na]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[\\\na]]', new Context())), undefined);
@@ -35,10 +38,6 @@ describe('Unit: parser/inline/reference', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('[[ a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[[ a ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[[\\ a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('[[<wbr>a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[a]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[a ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[a  ]]', new Context())), [['<sup class="reference"><span>a</span></sup>'], '']);
@@ -81,7 +80,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser, input('[[^A| b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[^A|  ]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[^A|<wbr>]]', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('[[^A|<wbr>b]]', new Context())), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[[^A|<wbr>b]]', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('[[^A|^]]', new Context())), [['<sup class="reference" data-abbr="A"><span>^</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[^A|^B]]', new Context())), [['<sup class="reference" data-abbr="A"><span>^B</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[[^1]]', new Context())), [['<sup class="invalid"><span>^1</span></sup>'], '']);

package/src/parser/inline/reference.ts

@@ -5,7 +5,7 @@ import { union, subsequence, some, precedence, state, constraint, surround, isBa
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
-import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -14,7 +14,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   precedence(1, state(State.annotation | State.reference,
   subsequence([
     abbr,
-    trimBlankStart(some(inline, ']', [[']', 1]])),
+    beforeNonblank(some(inline, ']', [[']', 1]])),
   ]))),
   ']]',
   false,

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

@@ -46,7 +46,12 @@ describe('Unit: parser/inline/ruby', () => {
       assert.deepStrictEqual(inspect(parser, input('[AB](a b c)', new Context())), [['<ruby>AB<rp>(</rp><rt>a b c</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[A B](ab)', new Context())), [['<ruby>A<rp>(</rp><rt>ab</rt><rp>)</rp>B<rt></rt></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[A B](a b)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rp>(</rp><rt>b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[A B](a b )', new Context())), [['<ruby>A B<rp>(</rp><rt>a b</rt><rp>)</rp></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](a  )', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC]( b)', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[ABC]( b )', new Context())), [['<ruby>A<rt></rt>B<rp>(</rp><rt>b</rt><rp>)</rp>C<rt></rt></ruby>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('[ABC](  c)', new Context())), [['<ruby>A<rt></rt>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[ABC](a  c)', new Context())), [['<ruby>A<rp>(</rp><rt>a</rt><rp>)</rp>B<rt></rt>C<rp>(</rp><rt>c</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[東方](とう　ほう)', new Context())), [['<ruby>東<rp>(</rp><rt>とう</rt><rp>)</rp>方<rp>(</rp><rt>ほう</rt><rp>)</rp></ruby>'], '']);
       assert.deepStrictEqual(inspect(parser, input('[秦　\\　　こころ](はた　の　こころ)', new Context())), [['<ruby>秦<rp>(</rp><rt>はた</rt><rp>)</rp>　<rp>(</rp><rt>の</rt><rp>)</rp>こころ<rp>(</rp><rt>こころ</rt><rp>)</rp></ruby>'], '']);

package/src/parser/inline/ruby.ts

@@ -4,7 +4,7 @@ import { List, Node } from '../../combinator/data/parser';
 import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { txt } from '../source';
-import { isTightNodeStart } from '../visibility';
+import { isNonblankNodeStart } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -16,7 +16,7 @@ export const ruby: RubyParser = lazy(() => bind(
       [1 | Backtrack.common, 3 | Backtrack.ruby],
       ([, ns]) => {
         ns && ns.last?.value === '' && ns.pop();
-        return isTightNodeStart(ns) ? ns : undefined;
+        return isNonblankNodeStart(ns) ? ns : undefined;
       })),
     dup(surround(
       '(', text, ')',

package/src/parser/node.ts

@@ -1,10 +1,17 @@
-import { invisibleHTMLEntityNames } from './api/normalize';
+import { invisibleBlankHTMLEntityNames } from './api/normalize';
 
 export const enum Flag {
   none,
-  invisible,
+  blank,
 }
 
-export function isinvisibleHTMLEntityName(name: string): boolean {
-  return invisibleHTMLEntityNames.includes(name);
-}
+export const isBlankHTMLEntityName: (name: string) => boolean = eval([
+  'name => {',
+  'switch(name){',
+  invisibleBlankHTMLEntityNames.map(name => `case '${name}':`).join(''),
+  'return true;',
+  'default:',
+  'return false;',
+  '}',
+  '}',
+].join(''));

package/src/parser/source/escapable.ts

@@ -1,5 +1,6 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
+import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { next } from './text';
@@ -34,7 +35,7 @@ export const escsource: EscapableSourceParser = ({ context }) => {
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'))]);
+      return new List([new Node(html('br'), Flag.blank)]);
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);

package/src/parser/source/text.ts

@@ -24,19 +24,16 @@ export const text: TextParser = input => {
           assert(char !== Command.Escape);
           return new List();
         default:
-          const flags = source[position + 1].trimStart()
-            ? Flag.none
-            : Flag.invisible;
           consume(1, context);
           context.position += 1;
-          return new List([new Node(source.slice(position + 1, context.position), flags)]);
+          return new List([new Node(source.slice(position + 1, context.position))]);
       }
     case '\r':
       consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'), Flag.invisible)]);
+      return new List([new Node(html('br'), Flag.blank)]);
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);
@@ -57,9 +54,7 @@ export const text: TextParser = input => {
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
       if (position === context.position || s && !linestart || lineend) return new List();
-      const str = source.slice(position, context.position);
-      const flags = str.length === 1 && str.trimStart() === '' ? Flag.invisible : Flag.none;
-      return new List([new Node(str, flags)]);
+      return new List([new Node(source.slice(position, context.position))]);
   }
 };
 

package/src/parser/source/unescapable.ts

@@ -1,5 +1,6 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
+import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { nonWhitespace, canSkip, next } from './text';
@@ -22,7 +23,7 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
-      return new List([new Node(html('br'))]);
+      return new List([new Node(html('br'), Flag.blank)]);
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);