securemark 0.291.1 → 0.292.0

package/src/parser/source/text.ts

@@ -1,66 +1,38 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { Command } from '../context';
 import { union, consume, focus } from '../../combinator';
-import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F（）［］｛｝]|\S#|[0-9A-Za-z]>/u;
-export const nonWhitespace = /[\S\n]|$/u;
-export const nonAlphanumeric = /[^0-9A-Za-z]|\S#|[0-9A-Za-z]>|$/u;
-const repeat = str(/^(.)\1*/);
-
-export const text: TextParser = ({ source, context }) => {
-  if (source === '') return;
-  const i = source.search(delimiter);
-  switch (i) {
-    case -1:
-      consume(source.length, context);
-      return [[source], ''];
-    case 0:
-      consume(1, context);
-      switch (source[0]) {
-        case '\r':
-          assert(!source.includes('\r', 1));
-          consume(-1, context);
-          return [[], source.slice(1)];
-        case Command.Escape:
-        case '\\':
-          switch (source[1]) {
-            case undefined:
-              return [[], ''];
-            case '\n':
-              assert(source[0] !== Command.Escape);
-              return [[], source.slice(1)];
-            default:
-              consume(1, context);
-              return [[source.slice(1, 2)], source.slice(2)];
-          }
+export const text: TextParser = input => {
+  const { context } = input;
+  const { source, position } = context;
+  if (position === source.length) return;
+  consume(1, context);
+  context.position += 1;
+  switch (source[position]) {
+    case '\r':
+      assert(!source.includes('\r', position + 1));
+      consume(-1, context);
+      return [[]];
+    case Command.Escape:
+    case '\\':
+      switch (source[position + 1]) {
+        case undefined:
+          return [[]];
         case '\n':
-          context.linebreak ||= source.length;
-          return [[html('br')], source.slice(1)];
-        case '*':
-        case '`':
-          return source[1] === source[0]
-            ? repeat({ source, context })
-            : [[source[0]], source.slice(1)];
+          assert(source[0] !== Command.Escape);
+          return [[]];
         default:
-          assert(source[0] !== '\n');
-          const b = source[0].trimStart() === '';
-          const i = b || isAlphanumeric(source[0])
-            ? source.search(b ? nonWhitespace : nonAlphanumeric) || 1
-            : 1;
-          assert(i > 0);
-          assert(!['\\', '\n'].includes(source[0]));
-          consume(i - 1, context);
-          return b && i === source.length
-              || b && source[i] === '\n'
-              || b && source[i] === '\\' && source[i + 1] === '\n'
-            ? [[], source.slice(i)]
-            : [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
+          consume(1, context);
+          context.position += 1;
+          return [[source.slice(position + 1, position + 2)]];
       }
+    case '\n':
+      context.linebreak ||= source.length - position;
+      return [[html('br')]];
     default:
-      consume(i, context);
-      return [[source.slice(0, i)], source.slice(i)];
+      assert(source[position] !== '\n');
+      return [[source[position]]];
   }
 };
 

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

@@ -1,45 +1,47 @@
 import { unescsource } from './unescapable';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/unescapable', () => {
   describe('unescsource', () => {
-    const parser = (source: string) => some(unescsource)({ source, context: {} });
+    const parser = (source: string) => some(unescsource)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab')), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz')), [['09', 'あい', 'AZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['a', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['0', '9', 'あ', 'い', 'A', 'Z', 'a', 'z'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser(' '), ctx), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser('  '), ctx), [[' ', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('   '), ctx), [[' ', ' ', ' '], '']);
+      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [[' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n'), ctx), [[' ', ' ', ' ', '<br>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n')), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\', '\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ ')), [['\\', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_')), [['\\', '_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0')), [['\\', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a')), [['\\', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\`')), [['\\', '`'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　')), [['\\', '　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\'), ctx), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\'), ctx), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\', '\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\ '), ctx), [['\\', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['\\', '_'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\`'), ctx), [['\\', '`'], '']);
+      assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['\\', '　'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);
     });
 
   });

package/src/parser/source/unescapable.ts

@@ -1,42 +1,27 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 import { html } from 'typed-dom/dom';
 
-export const unescsource: UnescapableSourceParser = ({ source, context }) => {
-  if (source === '') return;
-  const i = source.search(delimiter);
-  switch (i) {
-    case -1:
-      consume(source.length, context);
-      return [[source], ''];
-    case 0: {
+export const unescsource: UnescapableSourceParser = ({ context }) => {
+  const { source, position } = context;
+  if (position === source.length) return;
+  consume(1, context);
+  context.position += 1;
+  switch (source[position]) {
+    case '\r':
+      assert(!source.includes('\r', position + 1));
+      consume(-1, context);
+      return [[]];
+    case Command.Escape:
       consume(1, context);
-      switch (source[0]) {
-        case '\r':
-          assert(!source.includes('\r', 1));
-          consume(-1, context);
-          return [[], source.slice(1)];
-        case Command.Escape:
-          consume(1, context);
-          return [[source.slice(1, 2)], source.slice(2)];
-        case '\n':
-          context.linebreak ||= source.length;
-          return [[html('br')], source.slice(1)];
-        default:
-          assert(source[0] !== '\n');
-          const b = source[0].trimStart() === '';
-          const i = b || isAlphanumeric(source[0])
-            ? source.search(b ? nonWhitespace : nonAlphanumeric) || 1
-            : 1;
-          assert(i > 0);
-          consume(i - 1, context);
-          return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
-      }
-    }
+      context.position += 1;
+      return [[source.slice(position + 1, position + 2)]];
+    case '\n':
+      context.linebreak ||= source.length - position;
+      return [[html('br')]];
     default:
-      consume(i, context);
-      return [[source.slice(0, i)], source.slice(i)];
+      assert(source[position] !== '\n');
+      return [[source[position]]];
   }
 };

package/src/parser/source.ts

@@ -14,5 +14,5 @@ export import AnyLineParser = SourceParser.AnyLineParser;
 export { text, txt, linebreak } from './source/text';
 export { escsource } from './source/escapable';
 export { unescsource } from './source/unescapable';
-export { str } from './source/str';
+export { str, strs } from './source/str';
 export { contentline, emptyline, anyline } from './source/line';

package/src/parser/util.ts

@@ -1,6 +1,7 @@
 import { min } from 'spica/alias';
+import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { Parser, Result, Ctx, Node, Context, eval, exec } from '../combinator/data/parser';
+import { Parser, Result, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
 import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
@@ -22,67 +23,69 @@ export function lineable<N extends HTMLElement | string>(parser: Parser<N>, trim
     trim === 0);
 }
 
-export function repeat<P extends Parser<HTMLElement | string>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
-export function repeat<N extends HTMLElement | string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: Ctx) => N[], termination: (acc: N[][], rest: string, prefix: number, postfix: number, state: boolean) => Result<string | N> = (acc, rest, prefix, postfix) => {
-  const nodes = [];
+export function repeat<P extends Parser<HTMLElement |  string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
+export function repeat<N extends HTMLElement |  string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: MarkdownParser.Context) => N[], termination: (acc: N[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
+  const acc = [];
   if (prefix > 0) {
-    nodes.push(symbol[0].repeat(prefix));
-  }
-  for (let i = 0; i < acc.length; ++i) {
-    nodes.push(...acc[i]);
+    acc.push(symbol[0].repeat(prefix));
   }
+  acc.push(...nodes);
   if (postfix > 0) {
-    nodes.push(rest.slice(0, postfix));
-    rest = rest.slice(postfix);
+    const { source, position } = context;
+    acc.push(source.slice(position, position + postfix));
+    context.position += postfix;
   }
-  return [nodes, rest];
-}): Parser<string | N> {
-  return input => {
-    const { source, context } = input;
-    assert(source.startsWith(symbol));
-    let acc: N[][] = [];
+  return [acc];
+}): Parser<string | N, MarkdownParser.Context> {
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    assert(source.startsWith(symbol, context.position));
+    let nodes: N[] = [];
     let i = symbol.length;
-    while (source[i] === source[0]) ++i;
-    let rest = source.slice(i);
+    while (source[context.position + i] === source[context.position]) ++i;
+    context.position += i;
     let state = false;
     for (; i >= symbol.length; i -= symbol.length) {
-      if (acc.length > 0 && rest.startsWith(symbol)) {
-        acc = [cons(acc.flat(), context)];
-        rest = rest.slice(symbol.length);
+      if (nodes.length > 0 && source.startsWith(symbol, context.position)) {
+        nodes = cons(nodes, context);
+        context.position += symbol.length;
         continue;
       }
-      const result = parser({ source: rest, context });
+      const buf = context.buffer;
+      context.buffer = nodes;
+      const result = parser(input);
+      context.buffer = buf;
       if (result === undefined) break;
-      const nodes = eval(result);
-      rest = exec(result);
-      acc.push(nodes);
+      nodes = eval(result);
       switch (nodes.at(-1)) {
-        case Command.Escape:
-          assert(!rest.startsWith(symbol));
+        case Command.Cancel:
+          assert(!source.startsWith(symbol, context.position));
           nodes.pop();
           state = false;
           break;
         case Command.Separator:
-          assert(!rest.startsWith(symbol));
+          assert(!source.startsWith(symbol, context.position));
           nodes.pop();
           state = true;
           continue;
         default:
-          acc = [cons(acc.flat(), context)];
+          nodes = cons(nodes, context);
           state = true;
           continue;
       }
       break;
     }
-    if (acc.length === 0) return;
+    if (nodes.length === 0) return;
     const prefix = i;
     i = 0;
-    for (let len = min(prefix, rest.length); i < len && rest[i] === symbol[0];) {
+    for (let len = min(prefix, source.length - context.position); i < len && source[context.position + i] === symbol[0];) {
       ++i;
     }
     const postfix = i;
-    return termination(acc, rest, prefix, postfix, state);
-  };
+    context.range = context.position - position;
+    return termination(nodes, context, prefix, postfix, state);
+  });
 }
 
 export function invalid(

package/src/parser/visibility.ts

@@ -22,7 +22,7 @@ export function visualize<N extends HTMLElement | string>(parser: Parser<N>): Pa
   return union([
     convert(
       source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
-      verify(parser, (ns, rest) => !rest && hasVisible(ns)),
+      verify(parser, (ns, { source, position }) => position === source.length && hasVisible(ns)),
       false),
     some(union([linebreak, unescsource])),
   ]);
@@ -37,6 +37,7 @@ function hasVisible(
     }
     else {
       if (node.innerText.trimStart()) return true;
+      if (node.classList.contains('reference')) return true;
       //if (state & State.media ^ State.media &&
       //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
     }
@@ -79,35 +80,38 @@ export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N> {
       : undefined;
 }
 function isTightStart(input: Input<MarkdownParser.Context>, except?: string): boolean {
-  const { source } = input;
-  if (source === '') return true;
-  if (except && source.slice(0, except.length) === except) return false;
-  switch (source[0]) {
+  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[1]?.trimStart() !== '';
+      return source[position + 1]?.trimStart() !== '';
     case '&':
       switch (true) {
-        case source.length > 2
-          && source[1] !== ' '
+        case source.length - position > 2
+          && source[position + 1] !== ' '
           && eval(unsafehtmlentity(input))?.[0]?.trimStart() === '':
+          context.position = position;
           return false;
       }
+      context.position = position;
       return true;
     case '<':
       switch (true) {
-        case source.length >= 5
-          && source.slice(0, 4) === '<wbr'
-          && (source[5] === '>' || /^<wbr[^\S\n]*>/.test(source)):
+        case source.length - position >= 5
+          && source.startsWith('<wbr', position)
+          && (source[position + 5] === '>' || /^<wbr[^\S\n]*>/.test(source.slice(position))):
           return false;
       }
       return true;
     default:
-      return source[0].trimStart() !== '';
+      return source[position].trimStart() !== '';
   }
 }
 
@@ -199,9 +203,9 @@ export function trimBlankNodeEnd<N extends HTMLElement | string>(nodes: N[]): N[
     : [];
   for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes.at(-1)!, -1);) {
     if (typeof node === 'string') {
-      const len = node.trimEnd().length;
-      if (len > 0) {
-        nodes[nodes.length - 1] = node.slice(0, len) as N;
+      const str = node.trimEnd();
+      if (str.length > 0) {
+        nodes[nodes.length - 1] = str as N;
         break;
       }
     }

package/src/util/quote.ts

@@ -1,8 +1,10 @@
-import { exec } from '../combinator/data/parser';
+import { input } from '../combinator/data/parser';
 import { cite } from '../parser/block/reply/cite';
 
 export function quote(anchor: string, range: Range): string {
-  if (exec(cite({ source: `>>${anchor}`, context: {} })) !== '') throw new Error(`Invalid anchor: ${anchor}`);
+  const { context } = input('', {});
+  cite(input(`>>${anchor}`, context));
+  if (context.position !== context.source.length) throw new Error(`Invalid anchor: ${anchor}`);
   fit(range);
   const node = trim(range.cloneContents());
   if (!node.firstChild) return '';