securemark 0.293.0 → 0.293.2

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

@@ -23,7 +23,7 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('a\\\n'), ctx), [['<p>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\nb'), ctx), [['<p>a<br>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('a&NewLine;b'), ctx), [['<p>a b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('&Tab;&NewLine;'), ctx), [['<p>&amp;Tab;&amp;NewLine;</p>'], '']);
+      assert.deepStrictEqual(inspect(parser('&Tab;&NewLine;'), ctx), [['<p>&amp;NewLine;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>'), ctx), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>\n'), ctx), [['<p>&lt;wbr&gt;</p>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>\na'), ctx), [['<p>&lt;wbr&gt;<br>a</p>'], '']);
@@ -67,7 +67,6 @@ describe('Unit: parser/block/paragraph', () => {
       assert.deepStrictEqual(inspect(parser('[% a %]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]b'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span>b</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]\nb'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[% a %]</span></span><br>b</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a %%]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%% a %%]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span></p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]a'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span>a</p>'], '']);
       assert.deepStrictEqual(inspect(parser('[%\n<wbr>\n%]\na'), ctx), [['<p><span class="remark"><input type="checkbox"><span>[%<br>&lt;wbr&gt;<br>%]</span></span><br>a</p>'], '']);

package/src/parser/block/paragraph.ts

@@ -1,10 +1,9 @@
 import { ParagraphParser } from '../block';
 import { union, some, block, fmap } from '../../combinator';
 import { inline } from '../inline';
-import { linearize } from '../util';
 import { visualize, trimBlankEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(fmap(
-  visualize(trimBlankEnd(linearize(some(union([inline])), -1))),
+  visualize(trimBlankEnd(some(union([inline])))),
   ns => [html('p', defrag(ns))]));

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

@@ -1,5 +1,5 @@
 import { ReplyParser } from '../../block';
-import { union, line, validate, focus, open, fmap } from '../../../combinator';
+import { union, line, focus, open, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
 import { invalid } from '../../util';
@@ -7,8 +7,7 @@ import { html, define, defrag } from 'typed-dom/dom';
 
 export const syntax = />*(?=>>[^>\s]\S*[^\S\n]*(?:$|\n))/y;
 
-export const cite: ReplyParser.CiteParser = line(fmap(validate(
-  '>>',
+export const cite: ReplyParser.CiteParser = line(fmap(
   open(
     str(syntax),
     union([
@@ -18,8 +17,7 @@ export const cite: ReplyParser.CiteParser = line(fmap(validate(
       focus(/>>#\S*(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor' }, source)]]),
       focus(/>>https?:\/\/\S+(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)]]),
       focus(/>>.+(?=\s*$)/y, ({ context: { source } }) => [[source]]),
-    ]),
-  )),
+    ])),
   ([quotes, node]: [string, HTMLElement | string]) => [
     html('span',
       typeof node === 'object'

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

@@ -8,8 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = />+[^\S\n]/y;
 
-export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(validate(
-  '>',
+export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
   rewrite(
     some(validate(syntax, anyline)),
     linearize(convert(
@@ -21,7 +20,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(validate(
         linebreak,
         unescsource,
       ])),
-      false), -1))),
+      false), -1)),
   (ns: [string, ...(string | HTMLElement)[]]) => [
     html('span', { class: 'quote' }, defrag(ns)),
     html('br'),

package/src/parser/block/sidefence.ts

@@ -8,7 +8,7 @@ import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
   /(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/y,
-  union([source]), false),
+  union([source])),
   ([el]) => [
     define(el, {
       class: 'invalid',
@@ -23,7 +23,7 @@ const source: SidefenceParser.SourceParser = lazy(() => fmap(
   some(recursion(Recursion.block, union([
     focus(
       /(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/y,
-      convert(unindent, source, false, true), false),
+      convert(unindent, source, false, true)),
     rewrite(
       some(contentline, opener),
       convert(unindent, fmap(autolink, ns => [html('pre', defrag(ns))]), false, true)),

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, trimStart, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, fallback, lazy, fmap } from '../../combinator';
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlank } from '../visibility';
@@ -40,20 +40,20 @@ const align: AlignParser = fmap(open(
   '|',
   union([
     focus(/:-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'center' : 'start']], false),
+      [[source.at(-1) === ':' ? 'center' : 'start']]),
     focus(/-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'end' : '']], false),
+      [[source.at(-1) === ':' ? 'end' : '']]),
   ])),
   ns => [html('td', defrag(ns))]);
 
 const cell: CellParser = surround(
   /\|\s*(?=\S)/y,
-  trimStart(union([
+  union([
     close(medialink, /\s*(?=\||$)/y),
     close(media, /\s*(?=\||$)/y),
     close(shortmedia, /\s*(?=\||$)/y),
     trimBlank(some(inline, /\|/y, [[/[|\\]?\s*$/y, 9]])),
-  ])),
+  ]),
   /[^|]*/y, true);
 
 const head: CellParser.HeadParser = fmap(

package/src/parser/block/ulist.ts

@@ -1,10 +1,9 @@
 import { UListParser } from '../block';
 import { Recursion } from '../context';
-import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, trim, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_, ilistitem } from './ilist';
 import { inline, indexer, indexee, dataindex } from '../inline';
-import { linearize } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -20,7 +19,7 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
       inits([
         line(open(/-(?:$|[ \n])/y, subsequence([
           checkbox,
-          trim(visualize(linearize(trimBlank(some(union([indexer, inline]))), - 1))),
+          visualize(trimBlank(some(union([indexer, inline])))),
         ]), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),

package/src/parser/block.ts

@@ -63,6 +63,8 @@ export const block: BlockParser = reset(
           return pagebreak(input);
         case '~~~':
           return extension(input);
+        case '```':
+          return codeblock(input);
       }
       switch (source.slice(position, position + 2)) {
         case '$$':
@@ -91,8 +93,6 @@ export const block: BlockParser = reset(
         case '|':
           return table(input)
               || sidefence(input);
-        case '`':
-          return codeblock(input);
         case '$':
           return extension(input);
         case '>':

package/src/parser/context.ts

@@ -28,10 +28,10 @@ export const enum Recursion {
 }
 
 export const enum Backtrack {
-  link = 1 << 6,
-  ruby = 1 << 5,
-  doublebracket = 1 << 4,
-  bracket = 1 << 3,
+  bracket = 1 << 6,
+  doublebracket = 1 << 5,
+  link = 1 << 4,
+  ruby = 1 << 3,
   escbracket = 1 << 2,
   autolink = 0 << 2,
 }

package/src/parser/inline/annotation.ts

@@ -16,4 +16,4 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
       ? [[html('sup', { class: 'annotation' }, [html('span', defrag(trimBlankNodeEnd(ns)))])]]
       : undefined,
   undefined,
-  [3 | Backtrack.doublebracket, 1 | Backtrack.bracket])));
+  [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));

package/src/parser/inline/autolink/url.test.ts

@@ -10,12 +10,12 @@ describe('Unit: parser/inline/autolink/url', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(' http'), ctx), [[' ', 'http'], '']);
-      assert.deepStrictEqual(inspect(parser(' ttp'), ctx), [[' ', 'ttp'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://'), ctx), [[' ', 'http', ':', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://['), ctx), [[' ', 'http', ':', '/', '/', '['], '']);
-      assert.deepStrictEqual(inspect(parser(' http://]'), ctx), [[' ', 'http', ':', '/', '/', ']'], '']);
-      assert.deepStrictEqual(inspect(parser(' Http://host'), ctx), [[' ', 'Http', ':', '/', '/', 'host'], '']);
+      assert.deepStrictEqual(inspect(parser(' http'), ctx), [[' http'], '']);
+      assert.deepStrictEqual(inspect(parser(' ttp'), ctx), [[' ttp'], '']);
+      assert.deepStrictEqual(inspect(parser(' http://'), ctx), [[' ', 'http:', '//'], '']);
+      assert.deepStrictEqual(inspect(parser(' http://['), ctx), [[' ', 'http:', '//', '['], '']);
+      assert.deepStrictEqual(inspect(parser(' http://]'), ctx), [[' ', 'http:', '//', ']'], '']);
+      assert.deepStrictEqual(inspect(parser(' Http://host'), ctx), [[' ', 'Http:', '//host'], '']);
       assert.deepStrictEqual(inspect(parser(' http://[::ffff:0:0%1]'), ctx), [[' ', '<a class="invalid">http://[::ffff:0:0%1]</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://[::ffff:0:0/96]'), ctx), [[' ', '<a class="invalid">http://[::ffff:0:0/96]</a>'], '']);
     });
@@ -59,7 +59,7 @@ describe('Unit: parser/inline/autolink/url', () => {
       assert.deepStrictEqual(inspect(parser(' http://host^'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '^'], '']);
       assert.deepStrictEqual(inspect(parser(' http://host_'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser(' http://host/'), ctx), [[' ', '<a class="url" href="http://host/" target="_blank">http://host/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://host//'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser(' http://host//'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '//'], '']);
       assert.deepStrictEqual(inspect(parser(` http://host'`), ctx), [[' ', '<a class="url" href="http://host\'" target="_blank">http://host\'</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://host"'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '"'], '']);
       assert.deepStrictEqual(inspect(parser(' http://host`'), ctx), [[' ', '<a class="url" href="http://host" target="_blank">http://host</a>', '`'], '']);

package/src/parser/inline/autolink/url.ts

@@ -9,8 +9,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
     /(?<![0-9a-z][.+-]?)https?:\/\/(?=[\x21-\x7E])/y,
     precedence(1, some(union([
       verify(bracket, ns => ns.length > 0),
-      // 再帰に注意
-      some(unescsource, /[-+*=~^_/,.;:!?]{2}|[-+*=~^_,.;:!?]?(?=[\\"`|\[\](){}<>]|[^\x21-\x7E]|$)/y),
+      some(unescsource, /([-+*=~^_/])\1|[,.;:!?]{2}|[-+*=~^_,.;:!?]?(?=[\\"`\[\](){}<>（）［］｛｝|]|[^\x21-\x7E]|$)/y),
     ]), undefined, [[/[^\x21-\x7E]|\$/y, 9]])),
     false,
     [3 | Backtrack.autolink]),

package/src/parser/inline/autolink.ts

@@ -23,7 +23,7 @@ export const autolink: AutolinkParser = lazy(() =>
     url,
     email,
     // Escape unmatched email-like strings.
-    str(/[0-9a-z]+(?:[_.+-][0-9a-z]+@?|@(?=@))*/yi),
+    str(/[0-9a-z]+(?:[_.+-][0-9a-z]+[:@]?|:|@(?=@))*/yi),
     channel,
     account,
     // Escape unmatched account-like strings.

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

@@ -60,7 +60,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('[]'), ctx), [['[', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[a'), ctx), [['[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]'), ctx), [['[', 'a', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[==]'), ctx), [['[', '=', '=', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[==]'), ctx), [['[', '==', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$]$'), ctx), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']'), ctx), undefined);
     });
@@ -70,7 +70,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('{}'), ctx), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a'), ctx), [['{', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('{a}'), ctx), [['{', 'a', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('{==}'), ctx), [['{', '=', '=', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('{==}'), ctx), [['{', '==', '}'], '']);
       assert.deepStrictEqual(inspect(parser('}'), ctx), undefined);
     });
 

package/src/parser/inline/extension/index.ts

@@ -49,17 +49,18 @@ export const signature: IndexParser.SignatureParser = lazy(() => validate('|', s
   str(/\|(?!\\?\s)/y),
   some(union([
     unsafehtmlentity,
-    some(txt, /(?:[&$[\](){}<>"`]|\\?\n)/y),
+    some(txt, /(?:[$"`\[\](){}<>（）［］｛｝])/y),
   ]), ']'),
   /(?=])/y,
   false,
-  ([, ns]) => {
+  ([, ns], context) => {
     const index = identity('index', undefined, ns.join(''))?.slice(7);
-    return index
+    return index && context.linebreak === 0
       ? [[html('span', { class: 'indexer', 'data-index': index })]]
       : undefined;
   },
-  ([as, bs]) => bs && [unshift(as, bs)])));
+  ([as, bs]) => bs && [unshift(as, bs)],
+  [3 | Backtrack.bracket])));
 
 export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {
   if (ns.length === 0) return;

package/src/parser/inline/extension/indexer.test.ts

@@ -34,7 +34,6 @@ describe('Unit: parser/inline/extension/indexer', () => {
       assert.deepStrictEqual(inspect(parser(' [|*A*]'), ctx), [['<span class="indexer" data-index="*A*"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|\\`A\\`]'), ctx), [['<span class="indexer" data-index="`A`"></span>'], '']);
       assert.deepStrictEqual(inspect(parser(' [|\\$\\{A\\}\\$]'), ctx), [['<span class="indexer" data-index="${A}$"></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('  [|a]'), ctx), [['<span class="indexer" data-index="a"></span>'], '']);
     });
 
   });

package/src/parser/inline/extension/indexer.ts

@@ -10,7 +10,7 @@ import { html } from 'typed-dom/dom';
 // 継続的編集において最も簡便となる。
 
 export const indexer: ExtensionParser.IndexerParser = surround(
-  /\s+\[(?=\|\S)/y,
+  /\s\[(?=\|\S)/y,
   union([
     signature,
     focus(/\|(?=\])/y, () => [[html('span', { class: 'indexer', 'data-index': '' })]]),

package/src/parser/inline/html.ts

@@ -10,7 +10,7 @@ import { memoize } from 'spica/memoize';
 import { unshift, push, splice } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
-const tags = Object.freeze(['wbr', 'bdo', 'bdi']);
+const tags: readonly string[] = ['wbr', 'bdo', 'bdi'];
 const attrspecs = {
   wbr: {},
   bdo: {
@@ -81,7 +81,7 @@ function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | st
     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);
   }
-  const attrs = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -2 : as.length));
+  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)
   if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
   return h(tag as 'span', attrs, defrag(bs));
@@ -110,12 +110,13 @@ export function attributes(
   const attrs: Record<string, string | undefined> = {};
   for (let i = 0; i < params.length; ++i) {
     const param = params[i].trimStart();
+    if (param === '') continue;
     const name = param.split('=', 1)[0];
     const value = param !== name
       ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
-    invalidation ||= !spec || name in attrs;
-    if (spec && name in spec && !spec[name]) continue;
+    invalidation ||= name === '' || !spec || name in attrs;
+    if (name === '' || spec && name in spec && !spec[name]) continue;
     spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
       ? attrs[name] = value ?? ''
       : invalidation ||= !!spec;
@@ -132,7 +133,7 @@ export function attributes(
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 // [...document.querySelectorAll('tbody > tr > td:first-child')].map(el => el.textContent.slice(1, -1))
-const TAGS = Object.freeze([
+const TAGS: readonly string[] = [
   "html",
   "base",
   "head",
@@ -269,4 +270,4 @@ const TAGS = Object.freeze([
   "strike",
   "tt",
   "xmp",
-]);
+];

package/src/parser/inline/htmlentity.ts

@@ -1,9 +1,9 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
-import { union, validate, focus, fmap } from '../../combinator';
+import { union, focus, fmap } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = validate('&', focus(
+export const unsafehtmlentity: UnsafeHTMLEntityParser = focus(
   /&(?:[0-9A-Za-z]+;?)?/y,
   //({ source }) => [[parser(source) ?? `${Command.Error}${source}`], '']));
   ({ context }) => {
@@ -12,7 +12,7 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = validate('&', focus(
     return source.length > 1 && source.at(-1) === ';'
       ? [[parser(source) ?? source]]
       : [[source]];
-  }));
+  });
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),

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

@@ -11,14 +11,14 @@ describe('Unit: parser/inline/italic', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('///a'), ctx), [['///', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('///a ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a  ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\n///'), ctx), [['///', 'a', '<br>', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a', ' ', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a', '<br>', '/', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('///a/b'), ctx), [['///', 'a', '/', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a', '/', '/', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a*b///'), ctx), [['///', 'a', '*', 'b', '/', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a  ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\ ///'), ctx), [['///', 'a', ' ', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a\\\n///'), ctx), [['///', 'a', '<br>', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a/b'), ctx), [['///', 'a', '/b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a//b'), ctx), [['///', 'a', '//b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a*b///'), ctx), [['///', 'a', '*', 'b', '///'], '']);
       assert.deepStrictEqual(inspect(parser('/// ///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('/// a///'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('/// a ///'), ctx), undefined);
@@ -52,9 +52,9 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('//////a///'), ctx), [['///', '<i>a</i>'], '']);
       assert.deepStrictEqual(inspect(parser('//////a///b'), ctx), [['///', '<i>a</i>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('//////a////'), ctx), [['///', '<i>a</i>', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('//////a////b'), ctx), [['///', '<i>a</i>', '/', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('//////a/////'), ctx), [['///', '<i>a</i>', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser('//////a/////b'), ctx), [['///', '<i>a</i>', '/', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a////b'), ctx), [['///', '<i>a</i>', '/b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////'), ctx), [['///', '<i>a</i>', '//'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////b'), ctx), [['///', '<i>a</i>', '//b'], '']);
       assert.deepStrictEqual(inspect(parser('//////a//////'), ctx), [['<i><i>a</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('//////a///b///'), ctx), [['<i><i>a</i>b</i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a ///b//////'), ctx), [['<i>a <i>b</i></i>'], '']);

package/src/parser/inline/link.ts

@@ -29,7 +29,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
           ? [push(ns, [Command.Separator])]
           : undefined,
       undefined,
-      [3 | Backtrack.link, 2 | Backtrack.ruby, 3 | Backtrack.bracket])),
+      [3 | Backtrack.bracket, 3 | Backtrack.link, 2 | Backtrack.ruby])),
     // `{ `と`{`で個別にバックトラックが発生し+1nされる。
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
     dup(surround(
@@ -87,11 +87,6 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
   ([params, content = []]: [string[], (HTMLElement | string)[]], context) =>
     [[parse(defrag(content), params, context)]]))))));
 
-export const linemedialink: LinkParser.LineMediaLinkParser = surround(
-  /(?<=^|[\r\n])/y,
-  union([medialink]),
-  /(?=[^\S\n]*(?:$|\n))/y);
-
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
   creation(10,
   bind(reverse(tails([

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

@@ -14,11 +14,11 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('==a'), ctx), [['==', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('==a='), ctx), [['==', 'a', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\n=='), ctx), [['==', 'a', '<br>', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\ =='), ctx), [['==', 'a', ' ', '=', '='], '']);
-      assert.deepStrictEqual(inspect(parser('==a\\\n=='), ctx), [['==', 'a', '<br>', '=', '='], '']);
+      assert.deepStrictEqual(inspect(parser('==a =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a  =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\n=='), ctx), [['==', 'a', '<br>', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\ =='), ctx), [['==', 'a', ' ', '=='], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\\n=='), ctx), [['==', 'a', '<br>', '=='], '']);
       assert.deepStrictEqual(inspect(parser('== =='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a=='), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('== a =='), ctx), undefined);

package/src/parser/inline/math.ts

@@ -1,13 +1,13 @@
 import { MathParser } from '../inline';
 import { Backtrack, Recursion } from '../context';
-import { union, some, recursion, precedence, validate, rewrite, surround, lazy } from '../../combinator';
+import { union, some, recursion, precedence, rewrite, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])|:\/\//i;
 
-export const math: MathParser = lazy(() => validate('$', rewrite(
+export const math: MathParser = lazy(() => rewrite(
   union([
     surround(
       /\$(?={)/y,
@@ -35,7 +35,7 @@ export const math: MathParser = lazy(() => validate('$', rewrite(
               `"${source.match(forbiddenCommand)![0]}" command is forbidden`),
           },
       source)
-  ]])));
+  ]]));
 
 const bracket: MathParser.BracketParser = lazy(() => surround(
   str('{'),

package/src/parser/inline/media.ts

@@ -1,7 +1,7 @@
 import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
 import { subinput } from '../../combinator/data/parser';
-import { union, inits, tails, some, creation, recursion, precedence, constraint, validate, verify, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, creation, recursion, precedence, constraint, verify, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { unsafelink, uri, option as linkoption, resolve, decode } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
@@ -19,7 +19,7 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => constraint(State.media, validate(/![[{]/y, creation(10, open(
+export const media: MediaParser = lazy(() => constraint(State.media, creation(10, open(
   '!',
   bind(verify(fmap(tails([
     dup(surround(
@@ -104,12 +104,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, validate(/!
         return [define(link, { class: null, target: '_blank' }, [el])];
       })
       (subinput(`{ ${INSECURE_URI}${params.join('')} }`, context));
-  }))))));
-
-export const linemedia: MediaParser.LineMediaParser = surround(
-  /(?<=^|[\r\n])/y,
-  union([media]),
-  /(?=[^\S\n]*(?:$|\n))/y);
+  })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,

package/src/parser/inline/reference.ts

@@ -88,7 +88,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
       ? [unshift(as, bs)]
       : undefined;
   },
-  [3 | Backtrack.doublebracket, 1 | Backtrack.bracket])));
+  [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));
 
 // Chicago-Style
 const abbr: ReferenceParser.AbbrParser = surround(

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

@@ -16,25 +16,25 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[%a%]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[%a b%]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[% '), ctx), [['[%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% \n a'), ctx), [['[%', '<br>', ' ', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[% \n a'), ctx), [['[%', '<br>', ' a'], '']);
       assert.deepStrictEqual(inspect(parser('[%%]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[% [%'), ctx), [['[%', ' ', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% '), ctx), [['[%', ' ', '[%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% a'), ctx), [['[%', ' ', '[%', ' ', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [% a'), ctx), [['[%', ' ', '[%', ' a'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %]'), ctx), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a[%'), ctx), [['[%', ' ', 'a', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%'), ctx), [['[%', ' ', 'a', ' ', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [% '), ctx), [['[%', ' ', 'a', ' ', '[%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [% b'), ctx), [['[%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%% b'), ctx), [['[%', ' ', 'a', ' ', '[%%', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a [% b'), ctx), [['[%%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a[%'), ctx), [['[%', ' a', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [%'), ctx), [['[%', ' a ', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [% '), ctx), [['[%', ' a ', '[%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [% b'), ctx), [['[%', ' a ', '[%', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [%% b'), ctx), [['[%', ' a ', '<span class="invalid">[%%</span>', ' b'], '']);
+      assert.deepStrictEqual(inspect(parser('[%% a [% b'), ctx), [['<span class="invalid">[%%</span>'], ' a [% b']);
       assert.deepStrictEqual(inspect(parser('[%\\ a %]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[% a\\ %]'), ctx), [['[%', ' ', 'a', ' ', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a%]'), ctx), [['[%', ' ', 'a', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a %%]'), ctx), [['[%', ' ', 'a', ' ', '%', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [%% %]'), ctx), [['[%', ' ', '[%%', ' ', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% [% %%]'), ctx), [['[%%', ' ', '[%', ' ', '%', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a %]'), ctx), [['[%%', ' ', 'a', ' ', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a\\ %]'), ctx), [['[%', ' a', ' ', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a%]'), ctx), [['[%', ' a', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a %%]'), ctx), [['[%', ' a', ' ', '%', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [%% %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">[%%</span> %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%% [% %%]'), ctx), [['<span class="invalid">[%%</span>'], ' [% %%]']);
+      assert.deepStrictEqual(inspect(parser('[%% a %]'), ctx), [['<span class="invalid">[%%</span>'], ' a %]']);
       assert.deepStrictEqual(inspect(parser(' [% a %]'), ctx), undefined);
     });
 
@@ -49,10 +49,6 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], ' %]']);
       assert.deepStrictEqual(inspect(parser('[% %%] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %%] %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="remark"><input type="checkbox"><span>[% a %]</span></span> %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [%% a %%] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="remark"><input type="checkbox"><span>[%% a %%]</span></span> %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% a %%]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%% a %%]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% %] %%]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%% %] %%]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%% [% a %] %%]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%% <span class="remark"><input type="checkbox"><span>[% a %]</span></span> %%]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]b'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], 'b']);
       assert.deepStrictEqual(inspect(parser('[%\na\n%]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%<br>a<br>%]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% &a; %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&amp;a;</span> %]</span></span>'], '']);