securemark 0.293.2 → 0.293.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.293.2",
+  "version": "0.293.4",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/control/manipulation/indent.test.ts

@@ -12,12 +12,17 @@ describe('Unit: combinator/indent', () => {
       assert.deepStrictEqual(inspect(parser(input(' ', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input('  ', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input(' a\n', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a', ctx)), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a ', ctx)), ctx), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a\n', ctx)), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a \n', ctx)), ctx), [['a '], '']);
       assert.deepStrictEqual(inspect(parser(input('  a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('   a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('    a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('     a', ctx)), ctx), [[' a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a\n a', ctx)), ctx), [['a\na'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a\n  a', ctx)), ctx), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('    a\n        a', ctx)), ctx), [['a\n    a'], '']);
       assert.deepStrictEqual(inspect(parser(input('  a\n a', ctx)), ctx), [['a'], ' a']);
       assert.deepStrictEqual(inspect(parser(input(' \ta', ctx)), ctx), [['\ta'], '']);
       assert.deepStrictEqual(inspect(parser(input('\ta', ctx)), ctx), [['a'], '']);

package/src/combinator/control/manipulation/indent.ts

@@ -13,7 +13,7 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
   if (typeof opener === 'function') {
     separation = parser as boolean;
     parser = opener;
-    opener = /([ \t])\1*/y;
+    opener = / {1,4}|\t{1,2}/y;
   }
   assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
   assert(parser);

package/src/combinator/control/manipulation/surround.ts

@@ -157,7 +157,8 @@ export function setBacktrack(
   position: number,
   length: number = 1,
 ): void {
-  const { source } = context;
+  const { source, state = 0 } = context;
+  if (state === 0) return;
   if (position === source.length) return;
   if (length === 0) return;
   for (const backtrack of backtracks) {

package/src/combinator/data/parser/context/delimiter.ts

@@ -7,26 +7,24 @@ interface Delimiter {
   readonly signature: number | string;
   readonly matcher: (input: Input) => boolean | undefined;
   readonly precedence: number;
-  readonly linebreakable: boolean;
   state: boolean;
 }
 
 export class Delimiters {
   // 手間を惜しまなければ規定のパターンはすべて配列のインデクスに変換可能。
-  public static signature(pattern: string | RegExp | undefined, linebreakable: boolean): number | string {
+  public static signature(pattern: string | RegExp | undefined): number | string {
     switch (typeof pattern) {
       case 'undefined':
-        return +linebreakable;
+        return 1 << 7;
       case 'string':
         assert(pattern !== '\x00');
         if (pattern.length === 1) {
           const code = pattern.charCodeAt(0);
-          // 使用中のパターンの8ビット目が空いてるのでひとまずこうしとく
-          if ((code & 1 << 7) === 0) return code | +linebreakable << 7;
+          return code;
         }
-        return `s:${pattern}:${+linebreakable}`;
+        return `s:${pattern}`;
       case 'object':
-        return `r/${pattern.source}/${+linebreakable}`;
+        return `r/${pattern.source}`;
     }
   }
   public static matcher(pattern: string | RegExp | undefined): (input: Input<Ctx>) => true | undefined {
@@ -61,14 +59,13 @@ export class Delimiters {
       readonly signature: number | string;
       readonly matcher: (input: Input) => boolean | undefined;
       readonly precedence: number;
-      readonly linebreakable: boolean;
     }[]
   ): void {
     const { delimiters, stack } = this;
     // シグネチャ数以下
     assert(delimiters.length < 100);
     for (let i = 0; i < delims.length; ++i) {
-      const { signature, matcher, precedence, linebreakable } = delims[i];
+      const { signature, matcher, precedence } = delims[i];
       const memory = this.registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
       assert(memory.length === 0 || precedence === delimiters[index].precedence);
@@ -79,7 +76,6 @@ export class Delimiters {
           signature,
           matcher,
           precedence,
-          linebreakable,
           state: true,
         };
         delimiters[index] = delimiter;
@@ -134,14 +130,13 @@ export class Delimiters {
     }
   }
   public match(input: Input): boolean {
-    const { precedence = 0, linebreak = 0 } = input.context;
+    const { precedence = 0 } = input.context;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
       switch (delimiter.matcher(input)) {
         case true:
-          if (!delimiter.linebreakable && linebreak > 0) return false;
           return true;
         case false:
           return false;

package/src/combinator/data/parser/some.ts

@@ -1,8 +1,7 @@
 import { Parser, eval } from '../parser';
 import { Delimiters } from './context/delimiter';
-import { unshift, push } from 'spica/array';
 
-type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number, linebreak?: boolean];
+type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
 export function some<P extends Parser<unknown>>(parser: P, limit?: number): P;
 export function some<P extends Parser<unknown>>(parser: P, end?: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
@@ -10,11 +9,10 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
   if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   assert(parser);
   const match = Delimiters.matcher(end);
-  const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
-    signature: Delimiters.signature(delimiter, linebreakable),
+  const delims = delimiters.map(([delimiter, precedence]) => ({
+    signature: Delimiters.signature(delimiter),
     matcher: Delimiters.matcher(delimiter),
     precedence,
-    linebreakable,
   }));
   return input => {
     const { context } = input;
@@ -32,9 +30,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       const result = parser(input);
       if (result === undefined) break;
       nodes = nodes
-        ? nodes.length < eval(result).length / 8
-          ? unshift(nodes, eval(result))
-          : push(nodes, eval(result))
+        ? (nodes.push(...eval(result)), nodes)
         : eval(result);
       if (limit >= 0 && context.position - position > limit) break;
     }

package/src/combinator/data/parser.ts

@@ -1,5 +1,4 @@
 import { Delimiters } from './parser/context/delimiter';
-import { MarkdownParser } from '../../../markdown';
 
 export type Parser<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
   = (input: Input<C & Ctx>) => Result<N, C, D>;
@@ -38,8 +37,6 @@ export type IntermediateParser<P extends Parser<unknown>> = Parser<SubNode<P>, C
 type ExtractSubNode<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
-export function input(source: string, context: CtxOptions): Input<Ctx>;
-export function input(source: string, context: MarkdownParser.Options): Input<MarkdownParser.Context>;
 export function input(source: string, context: CtxOptions): Input<Ctx> {
   // @ts-expect-error
   context.source = source;

package/src/parser/api/bind.ts

@@ -78,7 +78,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header(input(seg, { header: index === 0 })) || block(input(seg, context)), []);
+      const es = eval(header(input(seg, { header: index === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []);
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/parse.ts

@@ -34,7 +34,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   const node = frag();
   let index = 0;
   for (const seg of segment(source)) {
-    node.append(...eval(header(input(seg, { header: index++ === 0 })) || block(input(seg, context)), []));
+    node.append(...eval(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []));
   }
   assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (opts.test) return node;

package/src/parser/block/dlist.test.ts

@@ -69,7 +69,7 @@ describe('Unit: parser/block/dlist', () => {
     it('indexer', () => {
       assert.deepStrictEqual(inspect(parser('~ a [|b]'), ctx), [['<dl><dt id="index::b">a<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a [|b]\\'), ctx), [['<dl><dt id="index::a_[|b]">a <span class="invalid">[|b]</span></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser('~ A'), ctx), [['<dl><dt id="index::A">A</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser('~ - [|b]'), ctx), [['<dl><dt id="index::b">-<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ *A*'), ctx), [['<dl><dt id="index::A"><em>A</em></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ `A`'), ctx), [['<dl><dt id="index::`A`"><code data-src="`A`">A</code></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ ${A}$'), ctx), [['<dl><dt id="index::${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></dt><dd></dd></dl>'], '']);

package/src/parser/block/heading.test.ts

@@ -79,6 +79,7 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a [|b] [|c]'), ctx), [['<h1 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a  [|b] \n'), ctx), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a \\[|b]'), ctx), [['<h1 id="index::a_[|b]">a [|b]</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# - [|b]'), ctx), [['<h1 id="index::b">-<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('## a [|b] [|c]'), ctx), [['<h2 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h2>'], '']);
     });
 

package/src/parser/block/olist.test.ts

@@ -32,6 +32,8 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('(1)'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n(1) a'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('I. '), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('A. '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(I) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(A) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(' 1. '), ctx), undefined);
@@ -117,12 +119,12 @@ describe('Unit: parser/block/olist', () => {
     });
 
     it('type', () => {
-      assert.deepStrictEqual(inspect(parser('i. '), ctx), [['<ol type="i" data-type="lower-roman"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('a. '), ctx), [['<ol type="a" data-type="lower-alpha"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('I. '), ctx), [['<ol type="I" data-type="upper-roman"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('A. '), ctx), [['<ol type="A" data-type="upper-alpha"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('a. \n1.\nc'), ctx), [['<ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('i. 1'), ctx), [['<ol type="i" data-type="lower-roman"><li id="index::1">1</li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n i. '), ctx), [['<ol><li><br><ol type="i" data-type="lower-roman"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n a. '), ctx), [['<ol><li><br><ol type="a" data-type="lower-alpha"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n I. '), ctx), [['<ol><li><br><ol type="I" data-type="upper-roman"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n A. '), ctx), [['<ol><li><br><ol type="A" data-type="upper-alpha"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n a. \n 1.\n c'), ctx), [['<ol><li><br><ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n i. 1'), ctx), [['<ol><li><br><ol type="i" data-type="lower-roman"><li id="index::1">1</li></ol></li></ol>'], '']);
     });
 
     it('checkbox', () => {
@@ -136,6 +138,7 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('1. [|a]'), ctx), [['<ol><li id="index::[|a]"><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|b]'), ctx), [['<ol><li id="index::b">a<span class="indexer" data-index="b"></span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. - [|]'), ctx), [['<ol><li>-<span class="indexer" data-index=""></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. [ ] [|a]'), ctx), [['<ol class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. [ ] a [|b]'), ctx), [['<ol class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]\n 1. c [|d]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span><ol><li id="index::d">c<span class="indexer" data-index="d"></span></li></ol></li></ol>'], '']);

package/src/parser/block/olist.ts

@@ -16,8 +16,8 @@ const openers = {
 
 export const olist: OListParser = lazy(() => block(validate(
   new RegExp([
-    /([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\. /y.source,
-    /\(([0-9]+|[a-z]+)\)(?:-[0-9]+)* /y.source,
+    /(?:[0-9]+)(?:-[0-9]+)*\. /y.source,
+    /\((?:[0-9]+)\)(?:-[0-9]+)* /y.source,
   ].join('|'), 'y'),
   olist_)));
 

package/src/parser/block/ulist.test.ts

@@ -75,6 +75,7 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('- [|a]'), ctx), [['<ul><li id="index::[|a]"><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|b]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- - [|b]'), ctx), [['<ul><li id="index::b">-<span class="indexer" data-index="b"></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] [|a]'), ctx), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] a [|b]'), ctx), [['<ul class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]\n - c [|d]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);

package/src/parser/block.ts

@@ -58,51 +58,53 @@ export const block: BlockParser = reset(
     input => {
       const { context: { source, position } } = input;
       if (position === source.length) return;
-      switch (source.slice(position, position + 3)) {
-        case '===':
-          return pagebreak(input);
-        case '~~~':
-          return extension(input);
-        case '```':
-          return codeblock(input);
-      }
-      switch (source.slice(position, position + 2)) {
-        case '$$':
-          return mathblock(input);
-        case '[$':
-          return extension(input);
-        case '[!':
+      const fst = source[position];
+      switch (fst) {
+        case '=':
+          if (source.startsWith('===', position)) return pagebreak(input);
+          break;
+        case '`':
+          if (source.startsWith('```', position)) return codeblock(input);
+          break;
+        case '~':
+          if (source.startsWith('~~~', position)) return extension(input);
+          if (source[position + 1] === ' ') return dlist(input);
+          break;
+        case '-':
+          if (source[position + 1] === ' ') return ulist(input) || ilist(input);
+          break;
+        case '+':
+        case '*':
+          if (source[position + 1] === ' ') return ilist(input);
+          break;
+        case '[':
+          switch (source[position + 1]) {
+            case '$':
+              return extension(input);
+            case '!':
+              return mediablock(input);
+          }
+          break;
+        case '!':
+          if (source[position + 1] === '>') return blockquote(input);
           return mediablock(input);
-        case '!>':
+        case '>':
+          if (source[position + 1] === '>') return blockquote(input) || reply(input);
           return blockquote(input);
-        case '>>':
-          return blockquote(input)
-              || reply(input);
-        case '- ':
-          return ulist(input)
-              || ilist(input);
-        case '+ ':
-        case '* ':
-          return ilist(input);
-        case '~ ':
-          return dlist(input);
-      }
-      switch (source[position]) {
         case '#':
           return heading(input);
-        case '|':
-          return table(input)
-              || sidefence(input);
         case '$':
+          if (source[position + 1] === '$') return mathblock(input);
           return extension(input);
-        case '>':
-          return blockquote(input);
-        case '!':
-          return mediablock(input);
+        case '|':
+          return table(input) || sidefence(input);
+        case '(':
+          return olist(input);
+        default:
+          if ('0' <= fst && fst <= '9') return olist(input);
       }
     },
     emptyline,
-    olist,
     paragraph
   ]) as any));
 

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

@@ -17,7 +17,7 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('(()))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(("))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(([))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((<bdi>))'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('(([%))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(( ))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(( (a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('((\n))'), ctx), undefined);

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

@@ -41,6 +41,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)'), ctx), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(\\a)'), ctx), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(==)'), ctx), [['<span class="paren">(==)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('("(\n))"(")'), ctx), [['<span class="paren">("(<br>)</span>'], ')"(")']);
       assert.deepStrictEqual(inspect(parser('($)$'), ctx), [['(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(')'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）'), ctx), [['（', '１，２', '）'], '']);
@@ -82,8 +83,9 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"(")"'), ctx), [['"', '(', '"'], ')"']);
       assert.deepStrictEqual(inspect(parser('"(("'), ctx), [['"', '(', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"'), ctx), [['"', '<span class="paren">(")</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"\n"'), ctx), [['"', '<br>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"\n"(")'), ctx), [['"', '<br>', '"', '(', '"'], ')']);
+      assert.deepStrictEqual(inspect(parser('"(\n)"(")'), ctx), [['"', '('], '\n)"(")']);
+      assert.deepStrictEqual(inspect(parser('"\n"'), ctx), [['"'], '\n"']);
+      assert.deepStrictEqual(inspect(parser('"\n"(")'), ctx), [['"'], '\n"(")']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -1,6 +1,6 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
-import { union, some, recursion, precedence, validate, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -11,93 +11,119 @@ const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
 const indexF = new RegExp(indexA.source.replace(', ', '[，、]')
   .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)));
 
-export const bracket: BracketParser = lazy(() => validate(/[([{（［｛"]/y, union([
-  surround(
-    str('('),
-    precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
-    str(')'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexA.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('（'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
-    str('）'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexF.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('['),
-    precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
-    str(']'),
-    true,
-    ([as, bs = [], cs], context) => {
-      if (context.state! & State.link) {
-        const { source, position, range = 0 } = context;
-        const head = position - range;
-        if (context.linebreak !== 0 || source[position] !== '{') {
+export const bracket: BracketParser = lazy(() => union([
+  input => {
+    const { context: { source, position } } = input;
+    switch (source[position]) {
+      case '(':
+        return p1(input);
+      case '（':
+        return p2(input);
+      case '[':
+        return s1(input);
+      case '［':
+        return s2(input);
+      case '{':
+        return c1(input);
+      case '｛':
+        return c2(input);
+      case '"':
+        return d1(input);
+    }
+  }
+])) as any;
+
+const p1 = lazy(() => surround(
+  str('('),
+  precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
+  str(')'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexA.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const p2 = lazy(() => surround(
+  str('（'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
+  str('）'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexF.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s1 = lazy(() => surround(
+  str('['),
+  precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
+  str(']'),
+  true,
+  ([as, bs = [], cs], context) => {
+    if (context.state! & State.link) {
+      const { source, position, range = 0 } = context;
+      const head = position - range;
+      if (context.linebreak !== 0 || source[position] !== '{') {
+        setBacktrack(context, [2 | Backtrack.link], head);
+      }
+      else {
+        context.state! ^= State.link;
+        const result = !isBacktrack(context, [1 | Backtrack.link])
+          ? textlink({ context })
+          : undefined;
+        context.position = position;
+        if (!result) {
           setBacktrack(context, [2 | Backtrack.link], head);
         }
-        else {
-          context.state! ^= State.link;
-          const result = !isBacktrack(context, [1 | Backtrack.link])
-            ? textlink({ context })
-            : undefined;
-          context.position = position;
-          if (!result) {
-            setBacktrack(context, [2 | Backtrack.link], head);
-          }
-          context.state! ^= State.link;
-          context.range = range;
-        }
+        context.state! ^= State.link;
+        context.range = range;
       }
-      return [push(unshift(as, bs), cs)];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('［'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
-    str('］'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('{'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
-    str('}'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('｛'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
-    str('｝'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  // 同一行内でしか閉じない以外括弧と同じ挙動
-  surround(
-    str('"'),
-    precedence(2, recursion(Recursion.bracket, some(inline, '"', [['"', 2, false]]))),
-    str('"'),
-    true,
-    ([as, bs = [], cs], context) =>
-      context.linebreak === 0
-        ? [push(unshift(as, bs), cs)]
-        : (context.position -= 1, [unshift(as, bs)]),
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-])));
+    }
+    return [push(unshift(as, bs), cs)];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s2 = lazy(() => surround(
+  str('［'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
+  str('］'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c1 = lazy(() => surround(
+  str('{'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
+  str('}'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c2 = lazy(() => surround(
+  str('｛'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
+  str('｝'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const d1 = lazy(() => surround(
+  str('"'),
+  // 改行の優先度を構文ごとに変える場合シグネチャの優先度対応が必要
+  precedence(2, recursion(Recursion.bracket, some(inline, /["\n]/y, [['"', 2], ['\n', 3]]))),
+  str('"'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));

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

@@ -40,6 +40,7 @@ describe('Unit: parser/inline/emphasis', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('*a *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*- *b**'), ctx), [['<em>- <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a **b***'), ctx), [['<em>a <strong>b</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a\\ *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a&Tab;*b**'), ctx), [['<em>a\t<em>b</em></em>'], '']);