securemark 0.296.0 → 0.296.2

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

@@ -84,7 +84,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser, input('[\\ ]{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('[‍]{b}', 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]{}', new Context())), undefined);

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { LinkParser } from '../inline';
 import { Context, State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, close, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
@@ -18,9 +18,9 @@ Object.setPrototypeOf(optspec, null);
 export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
   subsequence([
     constraint(State.link, state(State.linkers, dup(surround(
-      '[',
+      close('[', beforeNonblank),
       precedence(1,
-      beforeNonblank(some(union([inline]), ']', [[']', 1]]))),
+      some(union([inline]), ']', [[']', 1]])),
       ']',
       true,
       [3 | Backtrack.common | Backtrack.link, 2 | Backtrack.ruby],

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

@@ -44,6 +44,7 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser, input('==a&Tab;==b====', new Context())), [['<mark id="mark::a_b=33Mw2l">a\t<mark>b</mark></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('==a<wbr>==b====', new Context())), [['<mark id="mark::ab">a<wbr><mark>b</mark></mark>', '<a href="#mark::ab"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('==*==a==*==', new Context())), [['<mark id="mark::a"><em><mark>a</mark></em></mark>', '<a href="#mark::a"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('====a== b==', new Context())), [['<mark id="mark::a_b"><mark>a</mark> b</mark>', '<a href="#mark::a_b"></a>'], '']);
     });
 
   });

package/src/parser/inline/mark.ts

@@ -9,16 +9,16 @@ import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() =>
-  precedence(0, recursion(Recursion.inline, repeat('==', surround(
+  precedence(0, recursion(Recursion.inline, repeat('==', beforeNonblank, surround(
     '',
-    beforeNonblank(state(State.mark, some(union([inline]), '==', afterNonblank))),
+    state(State.mark, some(union([inline]), '==', afterNonblank)),
     '==',
     false, [],
     ([, bs], { buffer }) => buffer.import(bs),
     ([, bs], { buffer }) => bs && buffer.import(bs).push(new Node(Command.Cancel)) && buffer),
-    (nodes, { id, state }) => {
+    (nodes, { id, state }, nest) => {
       const el = html('mark', defrag(unwrap(nodes)));
-      if (state & State.linkers) return new List([new Node(el)]);
+      if (state & State.linkers || nest) return new List([new Node(el)]);
       define(el, { id: identity('mark', id, signature(el)) });
       return el.id
         ? new List([new Node(el), new Node(html('a', { href: `#${el.id}` }))])

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

@@ -49,7 +49,6 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser, input('![\\ ]{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('![‍]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![&a;]{b}', new Context())), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="&amp;a;"></a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('![[]{b}', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('![]]{b}', new Context())), undefined);

package/src/parser/inline/media.ts

@@ -53,7 +53,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, open(
       ? 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.head!.value.head?.flags)])), nodes.delete(nodes.last!)])),
   ([{ value: [{ value: text, flags }] }, { value: params }], context) => {
-    if (flags & Flag.invisible) return;
+    if (flags & Flag.blank) return;
     if (text) {
       const tmp = text;
       text = text.trim();

package/src/parser/inline/reference.ts

@@ -1,7 +1,7 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { union, subsequence, some, precedence, state, constraint, surround, open, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -10,11 +10,11 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, surround(
-  str('[['),
+  '[[',
   precedence(1, state(State.annotation | State.reference,
   subsequence([
     abbr,
-    beforeNonblank(some(inline, ']', [[']', 1]])),
+    open(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/inline/strong.ts

@@ -5,17 +5,17 @@ import { union, some, recursion, precedence, surround, lazy } from '../../combin
 import { inline } from '../inline';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { beforeNonblank, afterNonblank } from '../visibility';
+import { beforeNonblankWith, afterNonblank } from '../visibility';
 import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const strong: StrongParser = lazy(() => surround(
-  str('**', (source, position, range) => !source.startsWith('*', position + range)),
+  str('**', beforeNonblankWith(/(?!\*)/)),
   precedence(0, recursion(Recursion.inline,
-  beforeNonblank(some(union([
+  some(union([
     some(inline, '*', afterNonblank),
     emphasis,
-  ]))))),
+  ])))),
   str('**'),
   false, [],
   ([, bs]) => new List([new Node(html('strong', defrag(unwrap(bs))))]),

package/src/parser/node.ts

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

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/str.ts

@@ -1,10 +1,10 @@
 import { StrParser } from '../source';
 import { Parser, List, Node } from '../../combinator/data/parser';
-import { matcher } from '../../combinator';
+import { matcher, tester } from '../../combinator/data/delimiter';
 
-export function str(pattern: string | RegExp, verify?: (source: string, position: number, range: number) => boolean): StrParser;
-export function str(pattern: string | RegExp, verify?: (source: string, position: number, range: number) => boolean): Parser<string> {
-  return matcher(pattern, true, verify);
+export function str(pattern: string | RegExp, after?: string | RegExp): StrParser;
+export function str(pattern: string | RegExp, after?: string | RegExp): Parser<string> {
+  return matcher(pattern, true, after ? tester(after, false) : undefined);
 }
 
 export function strs(pattern: string, limit?: number): StrParser;

package/src/parser/source/text.ts

@@ -33,7 +33,7 @@ export const text: TextParser = input => {
       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)]);

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)]);

package/src/parser/util.ts

@@ -1,4 +1,5 @@
 import { Parser, Result, List, Node, failsafe } from '../combinator/data/parser';
+import { tester } from '../combinator/data/delimiter';
 import { Context, Command } from './context';
 import { min } from 'spica/alias';
 import { define } from 'typed-dom/dom';
@@ -10,8 +11,8 @@ export function* unwrap<N>(nodes: List<Node<N>> | undefined): Iterable<N> {
   }
 }
 
-export function repeat<P extends Parser<HTMLElement | string, Context>>(symbol: string, parser: P, cons: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => List<Node<Parser.Node<P>>>, termination?: (acc: List<Node<Parser.Node<P>>>, context: Context, prefix: number, postfix: number, state: boolean) => Result<string | Parser.Node<P>>): P;
-export function repeat<N extends HTMLElement | string>(symbol: string, parser: Parser<N>, cons: (nodes: List<Node<N>>, context: Context) => List<Node<N>>, termination: (acc: List<Node<N>>, context: Context, prefix: number, postfix: number, state: boolean) => Result<string | N, Context> = (nodes, context, prefix, postfix) => {
+export function repeat<P extends Parser<HTMLElement | string, Context>>(symbol: string, after: string | RegExp, parser: P, cons: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>, nest: boolean) => List<Node<Parser.Node<P>>>, termination?: (acc: List<Node<Parser.Node<P>>>, context: Context, prefix: number, postfix: number, state: boolean) => Result<string | Parser.Node<P>>): P;
+export function repeat<N extends HTMLElement | string>(symbol: string, after: string | RegExp, parser: Parser<N>, cons: (nodes: List<Node<N>>, context: Context, nest: boolean) => List<Node<N>>, termination: (acc: List<Node<N>>, context: Context, prefix: number, postfix: number, state: boolean) => Result<string | N, Context> = (nodes, context, prefix, postfix) => {
   const acc = new List<Node<string | N>>();
   if (prefix > 0) {
     acc.push(new Node(symbol[0].repeat(prefix)));
@@ -24,6 +25,7 @@ export function repeat<N extends HTMLElement | string>(symbol: string, parser: P
   }
   return acc;
 }): Parser<string | N, Context> {
+  const test = tester(after, false);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
@@ -32,10 +34,11 @@ export function repeat<N extends HTMLElement | string>(symbol: string, parser: P
     let i = symbol.length;
     for (; source[context.position + i] === source[context.position];) ++i;
     context.position += i;
+    if (test(input) === undefined) return;
     let state = false;
     for (; i >= symbol.length; i -= symbol.length) {
       if (nodes.length > 0 && source.startsWith(symbol, context.position)) {
-        nodes = cons(nodes, context);
+        nodes = cons(nodes, context, i > symbol.length);
         context.position += symbol.length;
         continue;
       }
@@ -57,7 +60,7 @@ export function repeat<N extends HTMLElement | string>(symbol: string, parser: P
           state = true;
           continue;
         default:
-          nodes = cons(nodes, context);
+          nodes = cons(nodes, context, i > symbol.length);
           state = true;
           continue;
       }

package/src/parser/visibility.ts

@@ -1,103 +1,73 @@
-import { Parser, Input, List, Node, failsafe } from '../combinator/data/parser';
-import { Context, Command } from './context';
+import { Parser, List, Node, failsafe } from '../combinator/data/parser';
+import { Command } from './context';
 import { Flag } from './node';
 import { convert, fmap } from '../combinator';
-import { invisibleHTMLEntityNames } from './api/normalize';
+import { invisibleBlankHTMLEntityNames } from './api/normalize';
 
-namespace invisible {
+namespace blank {
   export const line = new RegExp(
-    /((?:^|\n)[^\S\n]*(?=\S))((?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)+(?=$|\n))/g.source
-      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    /((?:^|\n)[^\S\n]*(?=\S))((?:[^\S\n]|\\(?=$|\s)|&IBHN;|<wbr ?>)+(?=$|\n))/g.source
+      .replace('IBHN', `(?:${invisibleBlankHTMLEntityNames.join('|')})`),
     'g');
   export const start = new RegExp(
-    /(?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)+/y.source
-      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    /(?:[^\S\n]|\\(?=$|\s)|&IBHN;|<wbr ?>)+/y.source
+      .replace('IBHN', `(?:${invisibleBlankHTMLEntityNames.join('|')})`),
     'y');
   export const unit = new RegExp(
-    /(?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)/y.source
-      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    /(?:[^\S\n]|\\(?=$|\s)|&IBHN;|<wbr ?>)/y.source
+      .replace('IBHN', `(?:${invisibleBlankHTMLEntityNames.join('|')})`),
     'y');
 }
 
 export function visualize<P extends Parser>(parser: P): P {
   return convert(
-    source => source.replace(invisible.line, `$1${Command.Escape}$2`),
+    source => source.replace(blank.line, `$1${Command.Escape}$2`),
     parser);
 }
 
-export const afterNonblank = nonblankWith('');
+export const beforeNonblank = beforeNonblankWith('');
+export const afterNonblank = afterNonblankWith('');
 export function blankWith(starts: '\n', delimiter: string | RegExp): RegExp {
   return new RegExp([
     // 空行除去
     // 完全な空行はエスケープ済みなので再帰的バックトラックにはならない。
-    String.raw`(?:${starts}(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr ?>)*)?`,
+    String.raw`(?:${starts}(?:\\?\s|&(?:${invisibleBlankHTMLEntityNames.join('|')});|<wbr ?>)*)?`,
     typeof delimiter === 'string'
       ? delimiter.replace(/[*+()\[\]]/g, '\\$&')
       : delimiter.source,
   ].join(''), 'y');
 }
-function nonblankWith(delimiter: string | RegExp): RegExp {
+export function beforeNonblankWith(delimiter: string | RegExp): RegExp {
   return new RegExp([
-    String.raw`(?<!\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr ?>)`,
     typeof delimiter === 'string'
       ? delimiter.replace(/[*+()\[\]]/g, '\\$&')
       : delimiter.source,
+    String.raw`(?!\\?\s|&(?:${invisibleBlankHTMLEntityNames.join('|')});|<wbr ?>)`,
   ].join(''), 'y');
 }
-
-//export function looseStart<P extends Parser<HTMLElement | string>>(parser: P): P;
-//export function looseStart<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
-//  return input =>
-//    isLooseStart(input)
-//      ? parser(input)
-//      : undefined;
-//}
-//const isLooseStart = reduce(({ source, context }: Input<Context>): boolean => {
-//  return isTightStart({ source: source.replace(invisible.start, ''), context });
-//}, ({ source }) => `${source}${Command.Separator}`);
-
-export function beforeNonblank<P extends Parser>(parser: P): P;
-export function beforeNonblank<N>(parser: Parser<N>): Parser<N, Context> {
-  return input =>
-    isTightStart(input)
-      ? parser(input)
-      : undefined;
-}
-function isTightStart(input: Input<Context>): boolean {
-  const { context } = input;
-  const { source, position } = context;
-  if (position === source.length) return true;
-  switch (source[position]) {
-    case ' ':
-    case '　':
-    case '\t':
-    case '\n':
-      return false;
-    default:
-      const reg = invisible.unit;
-      reg.lastIndex = position;
-      return !reg.test(source);
-  }
+function afterNonblankWith(delimiter: string | RegExp): RegExp {
+  return new RegExp([
+    String.raw`(?<!\s|&(?:${invisibleBlankHTMLEntityNames.join('|')});|<wbr ?>)`,
+    typeof delimiter === 'string'
+      ? delimiter.replace(/[*+()\[\]]/g, '\\$&')
+      : delimiter.source,
+  ].join(''), 'y');
 }
 
-export function isLooseNodeStart(nodes: List<Node<HTMLElement | string>>): boolean {
+export function isNonblankFirstLine(nodes: List<Node<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
   for (const node of nodes) {
-    if (isVisible(node)) return true;
-    if (typeof node.value === 'object' && node.value.tagName === 'BR') break;
+    if (isNonblank(node)) return true;
+    if (node.flags & Flag.blank && typeof node.value === 'object' && node.value.tagName === 'BR') break;
   }
   return false;
 }
-export function isTightNodeStart(nodes: List<Node<HTMLElement | string>>): boolean {
+export function isNonblankNodeStart(nodes: List<Node<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
-  return isVisible(nodes.head!, 0);
+  return isNonblank(nodes.head!, 0);
 }
-//export function isTightNodeEnd(nodes: readonly (HTMLElement | string)[]): boolean {
-//  if (nodes.length === 0) return true;
-//  return isVisible(nodes.at(-1)!, -1);
-//}
-function isVisible({ value: node, flags }: Node<HTMLElement | string>, strpos?: number): boolean {
-  if (flags & Flag.invisible) return false;
+function isNonblank({ value: node, flags }: Node<HTMLElement | string>, strpos?: number): boolean {
+  if (flags & Flag.blank) return false;
   if (typeof node !== 'string') return true;
   const str = node && strpos !== undefined
     ? node[strpos >= 0 ? strpos : node.length + strpos]
@@ -124,7 +94,7 @@ function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
     const { context } = input;
     const { source, position } = context;
     if (position === source.length) return;
-    const reg = invisible.start;
+    const reg = blank.start;
     reg.lastIndex = position;
     reg.test(source);
     context.position = reg.lastIndex || position;
@@ -137,41 +107,23 @@ export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P):
 export function trimBlankEnd<N extends HTMLElement>(parser: Parser<N>): Parser<string | N> {
   return fmap(parser, trimBlankNodeEnd);
 }
-//export function trimBlankNode<N extends HTMLElement | string>(nodes: N[]): N[] {
-//  return trimBlankNodeStart(trimBlankNodeEnd(nodes));
-//}
-//function trimBlankNodeStart<N extends HTMLElement | string>(nodes: N[]): N[] {
-//  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
-//    if (typeof node === 'string') {
-//      const pos = node.trimStart().length;
-//      if (pos > 0) {
-//        nodes[0] = node.slice(-pos) as N;
-//        break;
-//      }
-//    }
-//    else if (nodes.length === 1 && node.className === 'indexer') {
-//      break;
-//    }
-//    nodes.shift();
-//  }
-//  return nodes;
-//}
 export function trimBlankNodeEnd<N extends HTMLElement>(nodes: List<Node<string | N>>): List<Node<string | N>> {
-  const skip = nodes.last && ~nodes.last.flags & Flag.invisible && typeof nodes.last.value === 'object'
+  const skip = nodes.last && ~nodes.last.flags & Flag.blank && typeof nodes.last.value === 'object'
     ? nodes.last.value.className === 'indexer'
     : false;
   for (let node = skip ? nodes.last?.prev : nodes.last; node;) {
-    const visible = ~node.flags & Flag.invisible;
-    if (visible && typeof node.value === 'string') {
-      const str = node.value.trimEnd();
-      if (str.length > 0) {
-        node.value = str;
+    if (~node.flags & Flag.blank) {
+      if (typeof node.value === 'string') {
+        const str = node.value.trimEnd();
+        if (str.length > 0) {
+          node.value = str;
+          break;
+        }
+      }
+      else {
         break;
       }
     }
-    else if (visible) {
-      break;
-    }
     const target = node;
     node = node.prev;
     nodes.delete(target);