securemark 0.283.2 → 0.283.4

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,48 +18,50 @@ 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([
-  focus(
-    /^<wbr[^\S\n]*>/i,
-    () => [[h('wbr')], '']),
-  surround(
-    // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-    str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i), some(union([attribute])), str(/^[^\S\n]*>/), true,
-    ([as, bs = [], cs], rest) =>
-      [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest]),
-  match(
-    new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
-    memoize(
-    ([, tag]) =>
-      surround<HTMLParser.TagParser, string>(surround(
-        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)),
-        ]),
-        str(`</${tag}>`), true,
-        ([as, bs = [], cs], rest) =>
-          [[elem(tag, as, bs, cs)], rest],
-        ([as, bs = []], rest) =>
-          [[elem(tag, as, bs, [])], rest]))),
-  match(
-    /^<([a-z]+)(?=[^\S\n]|>)/i,
-    memoize(
-    ([, tag]) =>
-      surround<HTMLParser.TagParser, string>(surround(
-        str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
-        subsequence([
-          focus(/^[^\S\n]*\n/, some(inline)),
-          some(inline, `</${tag}>`, [[`</${tag}>`, 4]]),
-        ]),
-        str(`</${tag}>`), true,
-        ([as, bs = [], cs], rest) =>
-          [[elem(tag, as, bs, cs)], rest],
-        ([as, bs = []], rest) =>
-          [[elem(tag, as, bs, [])], rest]),
-    ([, tag]) => tag,
-    new Clock(10000))),
-]))))));
+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')], '']),
+    surround(
+      // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+      str(/^<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/i), some(union([attribute])), str(/^[^\S\n]*>/), true,
+      ([as, bs = [], cs], rest) =>
+        [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest]),
+    match(
+      new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
+      memoize(
+      ([, tag]) =>
+        surround<HTMLParser.TagParser, string>(surround(
+          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}>`), 3]]), true)),
+          ]),
+          str(`</${tag}>`), true,
+          ([as, bs = [], cs], rest) =>
+            [[elem(tag, as, bs, cs)], rest],
+          ([as, bs = []], rest) =>
+            [[elem(tag, as, bs, [])], rest]))),
+    match(
+      /^<([a-z]+)(?=[^\S\n]|>)/i,
+      memoize(
+      ([, tag]) =>
+        surround<HTMLParser.TagParser, string>(surround(
+          str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
+          subsequence([
+            focus(/^[^\S\n]*\n/, some(inline)),
+            some(inline, `</${tag}>`, [[`</${tag}>`, 3]]),
+          ]),
+          str(`</${tag}>`), true,
+          ([as, bs = [], cs], rest) =>
+            [[elem(tag, as, bs, cs)], rest],
+          ([as, bs = []], rest) =>
+            [[elem(tag, as, bs, [])], rest]),
+      ([, tag]) => tag,
+      new Clock(10000))),
+  ]))))));
 
 export const attribute: HTMLParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="[^"\n]*")?(?=[^\S\n]|>)/i),
@@ -208,7 +210,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

@@ -15,18 +15,18 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => validate(['[', '{'], union([
+export const link: LinkParser = lazy(() => union([
   medialink,
   textlink,
-])));
+]));
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recursion.ignore,
+export const textlink: LinkParser.TextLinkParser = lazy(() => validate(['[', '{'], 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(
@@ -40,11 +40,11 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recurs
     assert(content[0] !== '');
     if (content.length !== 0 && trimNodeEnd(content = defrag(content)).length === 0) return;
     return [[parse(content, params, context)], rest];
-  })))));
+  }))))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(1, Recursion.ignore,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => validate(['[', '{'], creation(1, Recursion.ignore,
   constraint(State.link | State.media, false,
-  syntax(2, State.linkers,
+  syntax(1, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
@@ -53,7 +53,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(1, Recu
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) =>
-    [[parse(defrag(content), params, context)], rest])))));
+    [[parse(defrag(content), params, context)], rest]))))));
 
 export const linemedialink: LinkParser.LineMediaLinkParser = surround(
   linebreak,
@@ -61,7 +61,8 @@ 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, 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]]),
+      syntax(4, State.none, 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' }, [
@@ -22,4 +22,4 @@ export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recurs
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, {}))))));
+  ([, fence]) => fence.length, {})))));

package/src/parser/inline/ruby.ts

@@ -8,18 +8,19 @@ 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, fmap(
+  syntax(1, State.all,
   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) => {
       const ns = eval(text({ source, context }), [undefined])[0];
       return ns && [[ns], rest];
     }),
-  ]),
+  ])),
   ([texts, rubies]) => {
     switch (true) {
       case rubies.length <= texts.length:
@@ -50,7 +51,7 @@ export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.i
             [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
         ];
     }
-  })))));
+  }))));
 
 const text: RubyParser.TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   const acc = [''];

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,8 @@ 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('"{{""}}')), [['"', '{', '{', '"', '"', '}', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('[#http://a/(<bdi>)]</bdi>')), [['<a class="index" href="#index::http://a/(&lt;bdi&gt;)">http://a/(&lt;bdi&gt;)</a>', '<', '/', 'bdi', '>'], '']);
     });
 
     it('uri', () => {

package/src/parser/visibility.ts

@@ -120,7 +120,7 @@ export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boo
 }
 //export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
 //  if (nodes.length === 0) return true;
-//  return isVisible(nodes[nodes.length - 1], -1);
+//  return isVisible(nodes.at(-1)!, -1);
 //}
 function isVisible(node: HTMLElement | string, strpos?: number): boolean {
   switch (typeof node) {
@@ -186,11 +186,11 @@ function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser
 //}
 export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
-    typeof nodes[nodes.length - 1] === 'object' &&
-    nodes[nodes.length - 1]['className'] === 'indexer'
+    typeof nodes.at(-1) === 'object' &&
+    nodes.at(-1)!['className'] === 'indexer'
     ? [nodes.pop()!]
     : [];
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[nodes.length - 1], -1);) {
+  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes.at(-1)!, -1);) {
     if (typeof node === 'string') {
       const pos = node.trimEnd().length;
       if (pos > 0) {