securemark 0.283.1 → 0.283.3

package/src/parser/block/dlist.ts

@@ -33,7 +33,7 @@ const desc: DListParser.DescriptionParser = block(fmap(open(
   false);
 
 function fillTrailingDescription(es: HTMLElement[]): HTMLElement[] {
-  return es.length > 0 && es[es.length - 1].tagName === 'DT'
+  return es.length > 0 && es.at(-1)!.tagName === 'DT'
     ? push(es, [html('dd')])
     : es;
 }

package/src/parser/context.ts

@@ -31,11 +31,11 @@ export const enum Recursion {
 }
 
 export const enum Backtrack {
-  template = 1 << 8,
-  media = 1 << 7,
-  ruby = 1 << 6,
-  link = 1 << 5,
-  index = 1 << 4,
-  url = 1 << 3,
+  template = 7 << 2,
+  index = 6 << 2,
+  ruby = 5 << 2,
+  link = 4 << 2,
+  media = 3 << 2,
+  url = 2 << 2,
   bracket = 1 << 2,
 }

package/src/parser/inline/annotation.ts

@@ -8,8 +8,8 @@ import { html, defrag } from 'typed-dom/dom';
 export const annotation: AnnotationParser = lazy(() => creation(1, Recursion.ignore, surround(
   '((',
   constraint(State.annotation, false,
-  syntax(6, State.annotation | State.media,
-  trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2]])))),
+  syntax(1, State.annotation | State.media,
+  trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 1]])))),
   '))',
   false,
   ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest],

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

@@ -25,9 +25,9 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => open(
         unsafelink)),
   ])));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(0, Recursion.terminal, precedence(2, union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(0, Recursion.terminal, precedence(1, union([
   surround(str('('), some(union([bracket, unescsource]), ')'), str(')'), true, undefined, undefined, 3 | Backtrack.url),
   surround(str('['), some(union([bracket, unescsource]), ']'), str(']'), true, undefined, undefined, 3 | Backtrack.url),
   surround(str('{'), some(union([bracket, unescsource]), '}'), str('}'), true, undefined, undefined, 3 | Backtrack.url),
-  surround(str('"'), precedence(3, some(unescsource, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.url),
+  surround(str('"'), precedence(2, some(unescsource, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.url),
 ]))));

package/src/parser/inline/autolink.ts

@@ -14,7 +14,7 @@ import { stringify } from '../util';
 export const autolink: AutolinkParser = lazy(() =>
   validate(/^(?:[@#>0-9a-z]|\S[#>]|[\r\n]!?https?:\/\/)/iu,
   constraint(State.autolink, false,
-  syntax(1, ~State.shortcut,
+  syntax(0, ~State.shortcut,
   union([
     some(union([lineurl])),
     fmap(some(union([

package/src/parser/inline/bracket.ts

@@ -6,42 +6,45 @@ import { State, Recursion, Backtrack } from '../context';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
+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(() => union([
-  surround(str('('), creation(0, Recursion.bracket, syntax(2, State.none, str(index))), str(')')),
-  surround(str('('), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, ')', [[')', 2]]))), str(')'), true,
+  surround(str('('), creation(0, Recursion.bracket, syntax(1, State.none, str(indexA))), str(')')),
+  surround(str('('), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, ')', [[')', 1]]))), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.bracket),
-  surround(str('（'), creation(0, Recursion.bracket, syntax(2, State.none, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))))), str('）')),
-  surround(str('（'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '）', [['）', 2]]))), str('）'), true,
+  surround(str('（'), creation(0, Recursion.bracket, syntax(1, State.none, str(indexF))), str('）')),
+  surround(str('（'), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, '）', [['）', 1]]))), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('['), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, ']', [[']', 2]]))), str(']'), true,
+  surround(str('['), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, ']', [[']', 1]]))), str(']'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.bracket),
-  surround(str('［'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '］', [['］', 2]]))), str('］'), true,
+  surround(str('［'), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, '］', [['］', 1]]))), str('］'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('{'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '}', [['}', 2]]))), str('}'), true,
+  surround(str('{'), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, '}', [['}', 1]]))), str('}'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.bracket),
-  surround(str('｛'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '｝', [['｝', 2]]))), str('｝'), true,
+  surround(str('｛'), creation(0, Recursion.bracket, syntax(1, State.none, some(inline, '｝', [['｝', 1]]))), str('｝'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('"'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '"', [[/^\\?\n/, 9], ['"', 3]]))), str('"'), true,
+  // 改行禁止はバックトラックなしでは内側の構文を破壊するため安易に行えない。
+  surround(str('"'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '"', [[/^\\?\n/, 9], ['"', 2]]))), str('"'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('“'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '”', [[/^\\?\n/, 9], ['”', 3]]))), str('”'), true,
+  surround(str('“'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '”', [[/^\\?\n/, 9], ['”', 2]]))), str('”'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('‘'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '’', [[/^\\?\n/, 9], ['’', 3]]))), str('’'), true,
+  surround(str('‘'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '’', [[/^\\?\n/, 9], ['’', 2]]))), str('’'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('「'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '」', [[/^\\?\n/, 9], ['」', 3]]))), str('」'), true,
+  surround(str('「'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '」', [[/^\\?\n/, 9], ['」', 2]]))), str('」'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('『'), creation(0, Recursion.bracket, syntax(3, State.none, some(inline, '』', [[/^\\?\n/, 9], ['』', 3]]))), str('』'), true,
+  surround(str('『'), creation(0, Recursion.bracket, syntax(2, State.none, some(inline, '』', [[/^\\?\n/, 9], ['』', 2]]))), str('』'), true,
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

package/src/parser/inline/code.ts

@@ -10,7 +10,7 @@ export const code: CodeParser = creation(1, Recursion.ignore, validate('`', matc
 
 function format(text: string): string {
   assert(text.length > 0);
-  return `${text[0]}${text[text.length - 1]}` === '  '
+  return `${text[0]}${text.at(-1)}` === '  '
       && text.trimStart()
     ? text.slice(1, -1)
     : text;

package/src/parser/inline/deletion.ts

@@ -9,7 +9,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() => creation(1, Recursion.inline, surround(
   str('~~', '~'),
-  syntax(1, State.none,
+  syntax(0, State.none,
   some(union([
     some(inline, blankWith('\n', '~~')),
     open('\n', some(inline, '~'), true),

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

@@ -12,10 +12,8 @@ describe('Unit: parser/inline/emphasis', () => {
       assert.deepStrictEqual(inspect(parser('*a *')), [['*', 'a'], ' *']);
       assert.deepStrictEqual(inspect(parser('*a  *')), [['*', 'a', ' '], ' *']);
       assert.deepStrictEqual(inspect(parser('*a\n*')), [['*', 'a'], '\n*']);
-      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['*', 'a'], '\nb*']);
       assert.deepStrictEqual(inspect(parser('*a\\ *')), [['*', 'a'], '\\ *']);
       assert.deepStrictEqual(inspect(parser('*a\\\n*')), [['*', 'a'], '\\\n*']);
-      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['*', 'a'], '\\\nb*']);
       assert.deepStrictEqual(inspect(parser('*a**b')), [['*', 'a', '**', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b*')), [['*', 'a', '**', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('* *')), undefined);
@@ -35,6 +33,8 @@ describe('Unit: parser/inline/emphasis', () => {
       assert.deepStrictEqual(inspect(parser('*a*')), [['<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*ab*')), [['<em>ab</em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a**')), [['<em>a</em>'], '*']);
+      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<em>a<br>b</em>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/emphasis.ts

@@ -11,11 +11,11 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => creation(1, Recursion.inline, surround(
   str('*', '*'),
-  syntax(1, State.none,
+  syntax(0, State.none,
   startTight(some(union([
     strong,
-    some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
-    open(some(inline, '*', [[/^\\?\n/, 9]]), union([
+    some(inline, blankWith('*')),
+    open(some(inline, '*'), union([
       emstrong,
       strong,
       emphasis,

package/src/parser/inline/emstrong.ts

@@ -11,16 +11,16 @@ import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
-  some(inline, blankWith('**'), [[/^\\?\n/, 9]]),
-  open(some(inline, '*', [[/^\\?\n/, 9]]), union([
+  some(inline, blankWith('**')),
+  open(some(inline, '*'), union([
     emstrong,
     strong,
   ])),
 ])));
 const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   strong,
-  some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
-  open(some(inline, '*', [[/^\\?\n/, 9]]), union([
+  some(inline, blankWith('*')),
+  open(some(inline, '*'), union([
     emstrong,
     strong,
     emphasis,
@@ -29,10 +29,10 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
 
 export const emstrong: EmStrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('***'),
-  syntax(1, State.none,
+  syntax(0, State.none,
   startTight(some(union([
-    some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
-    open(some(inline, '*', [[/^\\?\n/, 9]]), inline),
+    some(inline, blankWith('*')),
+    open(some(inline, '*'), inline),
   ])))),
   str(/^\*{1,3}/), false,
   ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {

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

@@ -12,12 +12,12 @@ import IndexParser = ExtensionParser.IndexParser;
 export const index: IndexParser = lazy(() => validate('[#', creation(1, Recursion.ignore, fmap(indexee(surround(
   '[#',
   constraint(State.index, false,
-  syntax(2, State.linkers | State.media,
+  syntax(1, State.linkers | State.media,
   startTight(
   some(inits([
     inline,
     signature,
-  ]), ']', [[/^\\?\n/, 9], [']', 2]])))),
+  ]), ']', [[/^\\?\n/, 9], [']', 1]])))),
   ']',
   false,
   ([, ns], rest) => [[html('a', { 'data-index': dataindex(ns) }, trimNodeEnd(defrag(ns)))], rest],
@@ -42,7 +42,7 @@ const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(0
   surround(str('('), some(union([bracket, txt]), ')'), str(')'), true, undefined, undefined, 3 | Backtrack.index),
   surround(str('['), some(union([bracket, txt]), ']'), str(']'), true, undefined, undefined, 3 | Backtrack.index),
   surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true, undefined, undefined, 3 | Backtrack.index),
-  surround(str('"'), precedence(3, some(txt, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.index),
+  surround(str('"'), precedence(2, some(txt, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.index),
 ])));
 
 export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {

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

@@ -105,7 +105,7 @@ assert(baseR(61, 62) === 'Z');
 assert(baseR(62, 62) === '10');
 
 export function signature(source: Element | DocumentFragment): string {
-  assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))'));
+  assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))') || source.nodeName === 'MARK');
   const target = source.cloneNode(true) as typeof source;
   for (let es = target.querySelectorAll('code[data-src], .math[data-src], .label[data-label], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'),
            len = es.length, i = 0; i < len; ++i) {
@@ -116,11 +116,13 @@ export function signature(source: Element | DocumentFragment): string {
         continue;
       case 'RT':
       case 'RP':
-      case 'BR':
       case 'UL':
       case 'OL':
         el.remove();
         continue;
+      case 'BR':
+        el.replaceWith('\n');
+        continue;
     }
     switch (el.className) {
       case 'math':

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

@@ -13,8 +13,8 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(1, Recursion.inline, surround(
   str(/^\[[:^|]/),
-  syntax(2, State.none,
-  startTight(some(union([inline]), ']', [[']', 2]]))),
+  syntax(1, State.none,
+  startTight(some(union([inline]), ']', [[']', 1]]))),
   str(']'), false,
   ([, bs], rest) => [[
     html('span', {

package/src/parser/inline/html.ts

@@ -18,7 +18,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(1, Recursion.inline, syntax(4, State.none, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(1, Recursion.inline, syntax(3, State.none, union([
   focus(
     /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),
@@ -35,7 +35,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 4]]), true)),
+          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]), true)),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -50,7 +50,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(inline, `</${tag}>`, [[`</${tag}>`, 4]]),
+          some(inline, `</${tag}>`, [[`</${tag}>`, 3]]),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -208,7 +208,7 @@ const TAGS = Object.freeze([
 
 function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: string[]): HTMLElement {
   assert(as.length > 0);
-  assert(as[0][0] === '<' && as[as.length - 1].slice(-1) === '>');
+  assert(as[0][0] === '<' && as.at(-1)!.slice(-1) === '>');
   if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag name "${tag}"`, as, bs, cs);
   if (cs.length === 0) return invalid('tag', `Missing the closing HTML tag "</${tag}>"`, as, bs, cs);
   if (bs.length === 0) return invalid('content', `Missing the content`, as, bs, cs);

package/src/parser/inline/htmlentity.ts

@@ -5,20 +5,20 @@ import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(1, Recursion.ignore, validate('&', focus(
-  /^&[0-9A-Za-z]+;/,
+  /^&[0-9A-Za-z]{1,99};/,
   ({ source }) => [[parse(source) ?? `\x1B${source}`], ''])));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([test]) => [
-    test[0] === '\x1B'
+  ([text]) => [
+    text[0] === '\x1B'
       ? html('span', {
           class: 'invalid',
           'data-invalid-syntax': 'htmlentity',
           'data-invalid-type': 'syntax',
           'data-invalid-message': 'Invalid HTML entity',
-        }, test.slice(1))
-      : test,
+        }, text.slice(1))
+      : text,
   ]);
 
 const parse = reduce((el => (entity: string): string | undefined => {

package/src/parser/inline/insertion.ts

@@ -9,7 +9,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, surround(
   str('++', '+'),
-  syntax(1, State.none,
+  syntax(0, State.none,
   some(union([
     some(inline, blankWith('\n', '++')),
     open('\n', some(inline, '+'), true),

package/src/parser/inline/link.ts

@@ -22,11 +22,11 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], union([
 
 export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link, false,
-  syntax(2, State.linkers | State.media,
+  syntax(1, State.linkers | State.media,
   bind(reverse(tails([
     dup(surround(
       '[',
-      trimBlankStart(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
+      trimBlankStart(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 1]])),
       ']',
       true, undefined, undefined, 1 | Backtrack.bracket)),
     dup(surround(
@@ -44,7 +44,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recurs
 
 export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link | State.media, false,
-  syntax(2, State.linkers,
+  syntax(1, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
@@ -61,7 +61,7 @@ export const linemedialink: LinkParser.LineMediaLinkParser = surround(
   /^(?=[^\S\n]*(?:$|\n))/);
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
-  creation(1, Recursion.ignore, precedence(2,
+  creation(1, Recursion.ignore, precedence(1,
   bind(reverse(tails([
     dup(surround(
       '[',

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

@@ -15,10 +15,8 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('==a ==')), [['==', 'a'], ' ==']);
       assert.deepStrictEqual(inspect(parser('==a  ==')), [['==', 'a', ' '], ' ==']);
       assert.deepStrictEqual(inspect(parser('==a\n==')), [['==', 'a'], '\n==']);
-      assert.deepStrictEqual(inspect(parser('==a\nb==')), [['==', 'a'], '\nb==']);
       assert.deepStrictEqual(inspect(parser('==a\\ ==')), [['==', 'a'], '\\ ==']);
       assert.deepStrictEqual(inspect(parser('==a\\\n==')), [['==', 'a'], '\\\n==']);
-      assert.deepStrictEqual(inspect(parser('==a\\\nb==')), [['==', 'a'], '\\\nb==']);
       assert.deepStrictEqual(inspect(parser('== ==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a==')), undefined);
       assert.deepStrictEqual(inspect(parser('== a ==')), undefined);
@@ -33,6 +31,8 @@ describe('Unit: parser/inline/mark', () => {
       assert.deepStrictEqual(inspect(parser('==a=b==')), [['<mark id="mark::a=b=3lYfIw">a=b</mark>', '<a href="#mark::a=b=3lYfIw"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==\\===')), [['<mark id="mark::=">=</mark>', '<a href="#mark::="></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a===')), [['<mark id="mark::a">a</mark>', '<a href="#mark::a"></a>'], '=']);
+      assert.deepStrictEqual(inspect(parser('==a\nb==')), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==a\\\nb==')), [['<mark id="mark::a_b=12Ta86">a<br>b</mark>', '<a href="#mark::a_b=12Ta86"></a>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/mark.ts

@@ -11,10 +11,10 @@ import { html, define, defrag } from 'typed-dom/dom';
 export const mark: MarkParser = lazy(() => creation(1, Recursion.inline, surround(
   str('==', '='),
   constraint(State.mark, false,
-  syntax(1, State.none,
+  syntax(0, State.none,
   startTight(some(union([
-    some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
-    open(some(inline, '=', [[/^\\?\n/, 9]]), mark),
+    some(inline, blankWith('==')),
+    open(some(inline, '='), mark),
   ]))))),
   str('=='), false,
   ([, bs], rest, { id }) => {

package/src/parser/inline/math.ts

@@ -8,10 +8,10 @@ const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
 export const math: MathParser = lazy(() => validate('$', creation(1, Recursion.ignore, rewrite(
   union([
-    surround('$', precedence(6, bracket), '$'),
+    surround('$', precedence(5, bracket), '$'),
     surround(
       /^\$(?![\s{}])/,
-      precedence(3, some(union([
+      precedence(2, some(union([
         bracket,
         focus(/^(?:[ ([](?!\$)|\\[\\{}$]?|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/, some(unescsource)),
       ]))),

package/src/parser/inline/media.ts

@@ -21,7 +21,7 @@ Object.setPrototypeOf(optspec, null);
 export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(1, Recursion.ignore, open(
   '!',
   constraint(State.media, false,
-  syntax(2, ~State.link,
+  syntax(1, ~State.link,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
@@ -78,7 +78,7 @@ const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(0, Rec
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
-  surround(str('"'), precedence(3, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
+  surround(str('"'), precedence(2, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
     undefined, undefined, 3 | Backtrack.media),
 ])));
 

package/src/parser/inline/reference.ts

@@ -9,10 +9,10 @@ import { html, defrag } from 'typed-dom/dom';
 export const reference: ReferenceParser = lazy(() => creation(1, Recursion.ignore, surround(
   '[[',
   constraint(State.reference, false,
-  syntax(6, State.annotation | State.reference | State.media,
+  syntax(1, State.annotation | State.reference | State.media,
   subsequence([
     abbr,
-    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 2]])),
+    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 1]])),
   ]))),
   ']]',
   false,

package/src/parser/inline/remark.ts

@@ -7,13 +7,13 @@ import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, syntax(5, State.none, match(
+export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, syntax(4, State.none, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>
     surround(
       open(str(`[${fence}`), some(text, new RegExp(String.raw`^\s+${fence}\]|^\S`)), true),
-      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 5]]),
+      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]]),
       close(some(text, /^\S/), str(`${fence}]`)), true,
       ([as, bs = [], cs], rest) => [[
         html('span', { class: 'remark' }, [

package/src/parser/inline/ruby.ts

@@ -8,11 +8,11 @@ import { isStartTightNodes } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, syntax(2, State.all, fmap(
+export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, syntax(1, State.all, fmap(
   sequence([
     bind(surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
       const ns = eval(text({ source, context }), [undefined])[0];
-      ns && ns[ns.length - 1] === '' && ns.pop();
+      ns && ns.at(-1) === '' && ns.pop();
       return ns && isStartTightNodes(ns) ? [[ns], rest] : undefined;
     }),
     bind(surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {

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

@@ -12,10 +12,8 @@ describe('Unit: parser/inline/strong', () => {
       assert.deepStrictEqual(inspect(parser('**a **')), [['**', 'a'], ' **']);
       assert.deepStrictEqual(inspect(parser('**a  **')), [['**', 'a', ' '], ' **']);
       assert.deepStrictEqual(inspect(parser('**a\n**')), [['**', 'a'], '\n**']);
-      assert.deepStrictEqual(inspect(parser('**a\nb**')), [['**', 'a'], '\nb**']);
       assert.deepStrictEqual(inspect(parser('**a\\ **')), [['**', 'a'], '\\ **']);
       assert.deepStrictEqual(inspect(parser('**a\\\n**')), [['**', 'a'], '\\\n**']);
-      assert.deepStrictEqual(inspect(parser('**a\\\nb**')), [['**', 'a'], '\\\nb**']);
       assert.deepStrictEqual(inspect(parser('**a*')), [['**', 'a', '*'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b**')), [['**', 'a', '<em>b</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('** **')), undefined);
@@ -33,6 +31,8 @@ describe('Unit: parser/inline/strong', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('**a**')), [['<strong>a</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**ab**')), [['<strong>ab</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\nb**')), [['<strong>a<br>b</strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\\\nb**')), [['<strong>a<br>b</strong>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/strong.ts

@@ -10,10 +10,10 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const strong: StrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('**', '*'),
-  syntax(1, State.none,
+  syntax(0, State.none,
   startTight(some(union([
-    some(inline, blankWith('**'), [[/^\\?\n/, 9]]),
-    open(some(inline, '*', [[/^\\?\n/, 9]]), union([
+    some(inline, blankWith('**')),
+    open(some(inline, '*'), union([
       emstrong,
       strong,
     ])),

package/src/parser/inline/template.ts

@@ -7,7 +7,7 @@ import { html } from 'typed-dom/dom';
 
 export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore, surround(
   '{{',
-  syntax(6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
+  syntax(1, State.all, some(union([bracket, escsource]), '}')),
   '}}',
   true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
@@ -20,6 +20,6 @@ const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.t
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true,
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
-  surround(str('"'), precedence(3, some(escsource, /^"|^\\?\n/)), str('"'), true,
+  surround(str('"'), precedence(2, some(escsource, /^"|^\\?\n/)), str('"'), true,
     undefined, undefined, 3 | Backtrack.template),
 ])));

package/src/parser/inline.test.ts

@@ -105,6 +105,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('<bdi>*<bdi>a</bdi>*</bdi>')), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>')), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>')), [['"', '<bdi><span class="paren">("")</span></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);
       assert.deepStrictEqual(inspect(parser('*<*>')), [['<em>&lt;</em>', '>'], '']);
       assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
@@ -150,7 +151,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((${))}$')), [['(', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('((a\nb))')), [['<span class="paren">(<span class="paren">(a<br>b)</span>)</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '(', '(', '"', '"', ')', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
@@ -159,7 +160,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a class="link" href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a class="link" href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['[', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '[', '[', '"', '"', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['[', '[', '[', '[', '[', '[', '[', '<a class="url" href="a">a</a>'], '']);
@@ -171,6 +172,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('"{{""}}')), [['"', '{', '{', '"', '"', '}', '}'], '']);
     });
 
     it('uri', () => {