securemark 0.295.8 → 0.296.0

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.invisible) 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/remark.ts

@@ -11,7 +11,7 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
   str(/\[%(?=[ \n])/y),
   precedence(3, recursion(Recursion.inline,
   some(union([inline]), /[ \n]%\]/y, [[/[ \n]%\]/y, 3]]))),
-  close(text, str(`%]`)),
+  close(text, str('%]')),
   true, [],
   ([as, bs = new List(), cs]) => new List([
     new Node(html('span', { class: 'remark' }, [

package/src/parser/inline/strong.ts

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

package/src/parser/node.ts

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

package/src/parser/source/str.ts

@@ -2,21 +2,23 @@ import { StrParser } from '../source';
 import { Parser, List, Node } from '../../combinator/data/parser';
 import { matcher } from '../../combinator';
 
-export function str(pattern: string | RegExp): StrParser;
-export function str(pattern: string | RegExp): Parser<string> {
-  return matcher(pattern, true);
+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 strs(pattern: string): StrParser;
-export function strs(pattern: string): Parser<string> {
+export function strs(pattern: string, limit?: number): StrParser;
+export function strs(pattern: string, limit: number = -1): Parser<string> {
   assert(pattern);
   return ({ context }) => {
     const { source } = context;
     let acc = '';
-    for (; context.position < source.length && source.startsWith(pattern, context.position);) {
+    for (let i = 0; i !== limit && context.position < source.length && source.startsWith(pattern, context.position); ++i) {
       acc += pattern;
       context.position += pattern.length;
     }
-    return new List([new Node(acc)]);
+    return acc
+      ? new List([new Node(acc)])
+      : undefined;
   };
 }

package/src/parser/source/text.ts

@@ -1,5 +1,6 @@
 import { TextParser, TxtParser } from '../source';
 import { State, Command } from '../context';
+import { Flag } from '../node';
 import { List, Node } from '../../combinator/data/parser';
 import { union, consume } from '../../combinator';
 import { html } from 'typed-dom/dom';
@@ -32,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'))]);
+      return new List([new Node(html('br'), Flag.invisible)]);
     default:
       assert(char !== '\n');
       if (context.sequential) return new List([new Node(char)]);
@@ -52,9 +53,8 @@ export const text: TextParser = input => {
       consume(i - 1, context);
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
-      return position === context.position || s && !linestart || lineend
-        ? new List()
-        : new List([new Node(source.slice(position, context.position))]);
+      if (position === context.position || s && !linestart || lineend) return new List();
+      return new List([new Node(source.slice(position, context.position))]);
   }
 };
 

package/src/parser/visibility.ts

@@ -1,10 +1,10 @@
 import { Parser, Input, List, Node, failsafe } from '../combinator/data/parser';
 import { Context, Command } from './context';
+import { Flag } from './node';
 import { convert, fmap } from '../combinator';
-import { unsafehtmlentity } from './inline/htmlentity';
 import { invisibleHTMLEntityNames } from './api/normalize';
 
-namespace blank {
+namespace invisible {
   export const line = new RegExp(
     /((?:^|\n)[^\S\n]*(?=\S))((?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)+(?=$|\n))/g.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
@@ -13,12 +13,15 @@ namespace blank {
     /(?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)+/y.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'y');
+  export const unit = new RegExp(
+    /(?:[^\S\n]|\\(?=$|\s)|&IHN;|<wbr ?>)/y.source
+      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
+    'y');
 }
 
-export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function visualize<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
+export function visualize<P extends Parser>(parser: P): P {
   return convert(
-    source => source.replace(blank.line, `$1${Command.Escape}$2`),
+    source => source.replace(invisible.line, `$1${Command.Escape}$2`),
     parser);
 }
 
@@ -42,114 +45,86 @@ function nonblankWith(delimiter: string | RegExp): RegExp {
   ].join(''), 'y');
 }
 
-//export function looseStart<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
-//export function looseStart<N extends HTMLElement | string>(parser: Parser<N>, except?: string): Parser<N> {
+//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, except)
+//    isLooseStart(input)
 //      ? parser(input)
 //      : undefined;
 //}
-//const isLooseStart = reduce(({ source, context }: Input<Context>, except?: string): boolean => {
-//  return isTightStart({ source: source.replace(blank.start, ''), context }, except);
-//}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
+//const isLooseStart = reduce(({ source, context }: Input<Context>): boolean => {
+//  return isTightStart({ source: source.replace(invisible.start, ''), context });
+//}, ({ source }) => `${source}${Command.Separator}`);
 
-export function tightStart<P extends Parser>(parser: P, except?: string): P;
-export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N, Context> {
+export function beforeNonblank<P extends Parser>(parser: P): P;
+export function beforeNonblank<N>(parser: Parser<N>): Parser<N, Context> {
   return input =>
-    isTightStart(input, except)
+    isTightStart(input)
       ? parser(input)
       : undefined;
 }
-function isTightStart(input: Input<Context>, except?: string): boolean {
+function isTightStart(input: Input<Context>): boolean {
   const { context } = input;
   const { source, position } = context;
   if (position === source.length) return true;
-  if (except && source.startsWith(except, position)) return false;
   switch (source[position]) {
     case ' ':
     case '　':
     case '\t':
     case '\n':
       return false;
-    case '\\':
-      return source[position + 1]?.trimStart() !== '';
-    case '&':
-      switch (true) {
-        case source.length - position > 2
-          && source[position + 1] !== ' '
-          && unsafehtmlentity(input)?.head?.value.trimStart() === '':
-          context.position = position;
-          return false;
-      }
-      context.position = position;
-      return true;
-    case '<':
-      switch (true) {
-        case source.length - position >= 5
-          && source.startsWith('<wbr', position)
-          && (source[position + 4] === '>' || source.startsWith(' >', position + 4)):
-          return false;
-      }
-      return true;
     default:
-      return source[position].trimStart() !== '';
+      const reg = invisible.unit;
+      reg.lastIndex = position;
+      return !reg.test(source);
   }
 }
 
 export function isLooseNodeStart(nodes: List<Node<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
-  for (const { value: node } of nodes) {
+  for (const node of nodes) {
     if (isVisible(node)) return true;
-    if (typeof node === 'object' && node.tagName === 'BR') break;
+    if (typeof node.value === 'object' && node.value.tagName === 'BR') break;
   }
   return false;
 }
 export function isTightNodeStart(nodes: List<Node<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
-  return isVisible(nodes.head!.value, 0);
+  return isVisible(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(node: HTMLElement | string, strpos?: number): boolean {
-  switch (typeof node) {
-    case 'string':
-      const char = node && strpos !== undefined
-        ? node[strpos >= 0 ? strpos : node.length + strpos]
-        : node;
-      switch (char) {
-        case '':
-        case ' ':
-        case '\t':
-        case '\n':
-          return false;
-        default:
-          return char.trimStart() !== '';
-      }
+function isVisible({ value: node, flags }: Node<HTMLElement | string>, strpos?: number): boolean {
+  if (flags & Flag.invisible) return false;
+  if (typeof node !== 'string') return true;
+  const str = node && strpos !== undefined
+    ? node[strpos >= 0 ? strpos : node.length + strpos]
+    : node;
+  switch (str) {
+    case '':
+    case ' ':
+    case '\t':
+    case '\n':
+      return false;
     default:
-      switch (node.tagName) {
-        case 'BR':
-        case 'WBR':
-          return false;
-        default:
-          return true;
-      }
+      return str.trimStart() !== '';
   }
 }
 
-// デフラグ前の非効率な後方トリムを避けるため必要のない限りtrimBlankStart+trimNodeEndで処理する。
+// 終端が必要な場合は無駄な後方トリムを避けるためtrimBlankStart+trimBlankNodeEndで処理する。
 export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function trimBlank<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
   return trimBlankStart(trimBlankEnd(parser));
 }
-export function trimBlankStart<P extends Parser>(parser: P): P;
-export function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
+function trimBlankStart<P extends Parser>(parser: P): P;
+function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
     if (position === source.length) return;
-    const reg = blank.start;
+    const reg = invisible.start;
     reg.lastIndex = position;
     reg.test(source);
     context.position = reg.lastIndex || position;
@@ -182,21 +157,24 @@ export function trimBlankEnd<N extends HTMLElement>(parser: Parser<N>): Parser<s
 //  return nodes;
 //}
 export function trimBlankNodeEnd<N extends HTMLElement>(nodes: List<Node<string | N>>): List<Node<string | N>> {
-  const skip = nodes.length > 0 &&
-    typeof nodes.last?.value === 'object' &&
-    nodes.last.value.className === 'indexer'
-    ? nodes.pop()
-    : undefined;
-  for (let node = nodes.last; nodes.length > 0 && !isVisible((node = nodes.last!).value, -1);) {
-    if (typeof node.value === 'string') {
+  const skip = nodes.last && ~nodes.last.flags & Flag.invisible && 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;
         break;
       }
     }
-    nodes.pop();
+    else if (visible) {
+      break;
+    }
+    const target = node;
+    node = node.prev;
+    nodes.delete(target);
   }
-  skip && nodes.push(skip);
   return nodes;
 }