securemark 0.284.0 → 0.285.1

package/src/parser/inline/emstrong.ts

@@ -1,14 +1,15 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
-import { Recursion } from '../context';
+import { Recursion, Command } from '../context';
 import { Result, IntermediateParser } from '../../combinator/data/parser';
-import { union, creation, precedence, some, surround, open, lazy, bind } from '../../combinator';
+import { union, some, creation, precedence, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
-import { unshift } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
   some(inline, blankWith('**')),
@@ -27,36 +28,69 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('***'),
-  precedence(0,
-  startTight(some(union([
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), inline),
-  ])))),
-  str(/^\*{1,3}/), false,
-  ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
-    assert(cs.length === 1);
-    switch (cs[0]) {
-      case '***':
-        return [[html('em', [html('strong', defrag(bs))])], rest];
-      case '**':
-        return bind<EmphasisParser>(
-          subemphasis,
-          (ds, rest) =>
-            rest.slice(0, 1) === '*'
-              ? [[html('em', unshift([html('strong', defrag(bs))], defrag(ds)))], rest.slice(1)]
-              : [unshift(['*', html('strong', defrag(bs))], ds), rest])
-          ({ source: rest, context }) ?? [['*', html('strong', defrag(bs))], rest];
-      case '*':
-        return bind<StrongParser>(
-          substrong,
-          (ds, rest) =>
-            rest.slice(0, 2) === '**'
-              ? [[html('strong', unshift([html('em', defrag(bs))], defrag(ds)))], rest.slice(2)]
-              : [unshift(['**', html('em', defrag(bs))], ds), rest])
-          ({ source: rest, context }) ?? [['**', html('em', defrag(bs))], rest];
-    }
-    assert(false);
-  },
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+// 開閉が明示的でない構文は開閉の不明確な記号による再帰的適用を行わず早く閉じるよう解析しなければならない。
+// このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
+export const emstrong: EmStrongParser = lazy(() => creation(1, Recursion.inline, validate('***',
+  precedence(0, repeat('***', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('*')),
+      open(some(inline, '*'), inline),
+    ]))),
+    str(/^\*{1,3}/), false,
+    ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
+      assert(cs.length === 1);
+      switch (cs[0]) {
+        case '***':
+          return [bs, rest];
+        case '**':
+          return bind<EmphasisParser>(
+            subemphasis,
+            (ds, rest) =>
+              rest.slice(0, 1) === '*'
+                ? [[html('em', unshift([html('strong', defrag(bs))], defrag(ds))), Command.Separator], rest.slice(1)]
+                : [push(unshift(['*', html('strong', defrag(bs))], ds), [Command.Separator]), rest])
+            ({ source: rest, context }) ?? [['*', html('strong', defrag(bs)), Command.Separator], rest];
+        case '*':
+          return bind<StrongParser>(
+            substrong,
+            (ds, rest) =>
+              rest.slice(0, 2) === '**'
+                ? [[html('strong', unshift([html('em', defrag(bs))], defrag(ds))), Command.Separator], rest.slice(2)]
+                : [push(unshift(['**', html('em', defrag(bs))], ds), [Command.Separator]), rest])
+            ({ source: rest, context }) ?? [['**', html('em', defrag(bs)), Command.Separator], rest];
+      }
+      assert(false);
+    },
+    ([as, bs], rest) => [push(unshift(as, bs), [Command.Escape]), rest]),
+    // 3以上の`*`に対してemの適用を保証する
+    nodes => [html('em', [html('strong', defrag(nodes))])],
+    (acc, rest, prefix, postfix, state) => {
+      const nodes = [];
+      let i = postfix;
+      if (state) while (i > 0) {
+        switch (i) {
+          case 1:
+            acc = [[html('em', acc.flat())]];
+            i -= 1;
+            break;
+          case 2:
+            acc = [[html('strong', acc.flat())]];
+            i -= 2;
+            break;
+          default:
+            acc = [[html('em', [html('strong', acc.flat())])]];
+            i -= 3;
+        }
+      }
+      if (prefix > postfix) {
+        nodes.push('*'.repeat(prefix - postfix));
+      }
+      for (let i = 0; i < acc.length; ++i) {
+        nodes.push(...acc[i]);
+      }
+      if (postfix > 0) {
+        rest = rest.slice(postfix);
+      }
+      return [nodes, rest];
+    })))));

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

@@ -1,10 +1,10 @@
 import { ExtensionParser } from '../../inline';
-import { State, Recursion, Backtrack } from '../../context';
-import { union, inits, some, creation, precedence, state, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { State, Recursion, Backtrack, BacktrackState, Command } from '../../context';
+import { union, inits, some, creation, precedence, state, constraint, validate, verify, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str } from '../../source';
-import { startTight, trimBlankNodeEnd } from '../../visibility';
+import { tightStart, trimBlankNodeEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
@@ -12,7 +12,7 @@ import IndexParser = ExtensionParser.IndexParser;
 export const index: IndexParser = lazy(() => constraint(State.index, false, creation(1, Recursion.ignore, fmap(indexee(surround(
   '[#',
   precedence(1, state(State.linkers | State.media,
-  startTight(
+  tightStart(
   some(inits([
     inline,
     signature,
@@ -23,7 +23,7 @@ export const index: IndexParser = lazy(() => constraint(State.index, false, crea
     trimBlankNodeEnd(ns).length > 0
       ? [[html('a', { 'data-index': dataindex(ns) }, defrag(ns))], rest]
       : undefined,
-  undefined, 1 | Backtrack.bracket)),
+  undefined, 1 | Backtrack.linebracket, Backtrack.bracket | BacktrackState.nobreak)),
   ([el]: [HTMLAnchorElement]) => [
     define(el,
       {
@@ -35,16 +35,20 @@ export const index: IndexParser = lazy(() => constraint(State.index, false, crea
 
 export const signature: IndexParser.SignatureParser = lazy(() => validate('|', creation(1, Recursion.ignore, fmap(open(
   /^\|(?!\\?\s)/,
-  some(union([bracket, txt]), ']')),
+  some(verify(union([bracket, txt]), ns => ns[0] !== Command.Escape), ']')),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity('index', undefined, ns.join(''))!.slice(7) }),
   ]))));
 
 const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
-  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(2, some(txt, '"')), str('"'), true, undefined, undefined, 3 | Backtrack.index),
+  surround(str('('), some(union([bracket, txt]), ')'), str(')'), true,
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.index),
+  surround(str('['), some(union([bracket, txt]), ']'), str(']'), true,
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.index),
+  surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true,
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.index),
+  surround(str('"'), precedence(2, some(txt, '"')), str('"'), true,
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.index),
 ])));
 
 export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Recursion } from '../../context';
-import { union, constraint, creation, surround, clear, fmap } from '../../../combinator';
+import { union, creation, constraint, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 

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

@@ -3,7 +3,7 @@ import { Recursion, Backtrack } from '../../context';
 import { union, some, creation, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { startTight } from '../../visibility';
+import { tightStart } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -14,7 +14,7 @@ import { html, defrag } from 'typed-dom/dom';
 export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creation(1, Recursion.inline, surround(
   str(/^\[[:^|]/),
   precedence(1,
-  startTight(some(union([inline]), ']', [[']', 1]]))),
+  tightStart(some(union([inline]), ']', [[']', 1]]))),
   str(']'), false,
   ([, bs], rest) => [[
     html('span', {

package/src/parser/inline/html.ts

@@ -3,7 +3,7 @@ import { Recursion } from '../context';
 import { union, subsequence, some, creation, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { isStartLooseNodes, blankWith } from '../visibility';
+import { isLooseNodeStart, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { Clock } from 'spica/clock';
 import { unshift, push, splice } from 'spica/array';
@@ -219,7 +219,7 @@ function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: strin
   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);
-  if (!isStartLooseNodes(bs)) return invalid('content', `Missing the visible content in the same line`, as, bs, cs);
+  if (!isLooseNodeStart(bs)) return invalid('content', `Missing the visible content in the same line`, as, bs, cs);
   const attrs = attributes('html', [], attrspecs[tag], as.slice(1, -1));
   return 'data-invalid-syntax' in attrs
     ? invalid('attribute', 'Invalid HTML attribute', as, bs, cs)

package/src/parser/inline/insertion.ts

@@ -1,19 +1,20 @@
 import { InsertionParser } from '../inline';
-import { Recursion } from '../context';
-import { union, some, creation, precedence, surround, open, lazy } from '../../combinator';
+import { Recursion, Command } from '../context';
+import { union, some, creation, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { str } from '../source';
 import { blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('++', '+'),
-  precedence(0,
-  some(union([
-    some(inline, blankWith('\n', '++')),
-    open('\n', some(inline, '+'), true),
-  ]))),
-  str('++'), false,
-  ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, validate('++',
+  precedence(0, repeat('++', surround(
+    '',
+    some(union([
+      some(inline, blankWith('\n', '++')),
+      open('\n', some(insertion, '+'), true),
+    ])),
+    '++', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    nodes => [html('ins', defrag(nodes))])))));

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

@@ -15,8 +15,8 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('///a\\ ///')), [['///', 'a'], '\\ ///']);
       assert.deepStrictEqual(inspect(parser('///a\\\n///')), [['///', 'a'], '\\\n///']);
       assert.deepStrictEqual(inspect(parser('///a/b')), [['///', 'a', '/', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a//b')), [['///', 'a', '//', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('///a*b///')), [['///', 'a', '*', 'b', '///'], '']);
+      assert.deepStrictEqual(inspect(parser('///a//b')), [['///', 'a', '/', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('///a*b///')), [['///', 'a', '*', 'b', '/', '/', '/'], '']);
       assert.deepStrictEqual(inspect(parser('/// ///')), undefined);
       assert.deepStrictEqual(inspect(parser('/// a///')), undefined);
       assert.deepStrictEqual(inspect(parser('/// a ///')), undefined);
@@ -25,8 +25,6 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('///\\ a///')), undefined);
       assert.deepStrictEqual(inspect(parser('///\\\na///')), undefined);
       assert.deepStrictEqual(inspect(parser('///<wbr>a///')), undefined);
-      assert.deepStrictEqual(inspect(parser('////a////')), undefined);
-      assert.deepStrictEqual(inspect(parser('/////a/////')), undefined);
       assert.deepStrictEqual(inspect(parser(' ///a///')), undefined);
     });
 
@@ -39,8 +37,29 @@ describe('Unit: parser/inline/italic', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('////a///')), [['/', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('////a///b')), [['/', '<i>a</i>'], 'b']);
+      assert.deepStrictEqual(inspect(parser('////a////')), [['/', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('////a////b')), [['/', '<i>a</i>', '/'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a///')), [['//', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a///b')), [['//', '<i>a</i>'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a////')), [['//', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a////b')), [['//', '<i>a</i>', '/'], 'b']);
+      assert.deepStrictEqual(inspect(parser('/////a/////')), [['//', '<i>a</i>', '//'], '']);
+      assert.deepStrictEqual(inspect(parser('/////a/////b')), [['//', '<i>a</i>', '//'], 'b']);
+      assert.deepStrictEqual(inspect(parser('//////a///')), [['///', '<i>a</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a///b')), [['///', '<i>a</i>', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a////')), [['///', '<i>a</i>', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a////b')), [['///', '<i>a</i>', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////')), [['///', '<i>a</i>', '/', '/'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a/////b')), [['///', '<i>a</i>', '/', '/', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a//////')), [['<i><i>a</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('//////a///b///')), [['<i><i>a</i>b</i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a ///b//////')), [['<i>a <i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a\\ ///b//////')), [['<i>a <i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a //////b/////////')), [['<i>a <i><i>b</i></i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///b///c///')), [['<i>a <i>b</i>c</i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///a ///b ///c/////////')), [['<i>a <i>b <i>c</i></i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a&Tab;///b//////')), [['<i>a\t<i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a<wbr>///b//////')), [['<i>a<wbr><i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///`a`///')), [['<i><code data-src="`a`">a</code></i>'], '']);

package/src/parser/inline/italic.ts

@@ -1,21 +1,22 @@
 import { ItalicParser } from '../inline';
-import { Recursion } from '../context';
-import { union, some, creation, precedence, surround, open, lazy } from '../../combinator';
+import { Recursion, Command } from '../context';
+import { union, some, creation, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 // 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
 // ある程度の長さのある文に使うのが望ましい。
-export const italic: ItalicParser = lazy(() => creation(1, Recursion.inline, surround(
-  str('///', '/'),
-  precedence(0,
-  startTight(some(union([
-    some(inline, blankWith('///')),
-    open(some(inline, '/'), italic),
-  ])))),
-  str('///'), false,
-  ([, bs], rest) => [[html('i', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+export const italic: ItalicParser = lazy(() => creation(1, Recursion.inline, validate('///',
+  precedence(0, repeat('///', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('///')),
+      open(some(inline, '/'), italic),
+    ]))),
+    '///', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    nodes => [html('i', defrag(nodes))])))));

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
-import { State, Recursion, Backtrack } from '../context';
-import { union, inits, tails, sequence, some, constraint, creation, precedence, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { State, Recursion, Backtrack, BacktrackState } from '../context';
+import { union, inits, tails, sequence, some, creation, precedence, state, constraint, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';
@@ -22,7 +22,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       '[',
       trimBlankStart(some(union([inline]), ']', [['\n', 9], [']', 1]])),
       ']',
-      true, undefined, undefined, 1 | Backtrack.bracket)),
+      true, undefined, undefined, 1 | Backtrack.linebracket, Backtrack.bracket | BacktrackState.nobreak)),
     dup(surround(
       /^{(?![{}])/,
       inits([uri, some(option)]),

package/src/parser/inline/mark.ts

@@ -1,26 +1,27 @@
 import { MarkParser } from '../inline';
-import { State, Recursion } from '../context';
-import { union, some, creation, precedence, constraint, surround, open, lazy } from '../../combinator';
+import { State, Recursion, Command } from '../context';
+import { union, some, creation, precedence, constraint, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
-import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { tightStart, blankWith } from '../visibility';
+import { repeat } from '../util';
+import { push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => constraint(State.mark, false, creation(1, Recursion.inline, surround(
-  str('==', '='),
-  precedence(0,
-  startTight(some(union([
-    some(inline, blankWith('==')),
-    open(some(inline, '='), mark),
-  ])))),
-  str('=='), false,
-  ([, bs], rest, { id }) => {
-    const el = html('mark', defrag(bs));
-    return [[
-      define(el, { id: identity('mark', id, signature(el)) }),
-      el.id && html('a', { href: `#${el.id}` }),
-    ], rest];
-  },
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+export const mark: MarkParser = lazy(() => constraint(State.mark, false, creation(1, Recursion.inline, validate('==',
+  precedence(0, repeat('==', surround(
+    '',
+    tightStart(some(union([
+      some(inline, blankWith('==')),
+      open(some(inline, '='), mark),
+    ]))),
+    '==', false,
+    ([, bs], rest) => [bs, rest],
+    ([, bs], rest) => [push(bs, [Command.Escape]), rest]),
+    (nodes, { id }) => {
+      const el = html('mark', defrag(nodes));
+      define(el, { id: identity('mark', id, signature(el)) });
+      return el.id
+        ? [el, el.id && html('a', { href: `#${el.id}` })]
+        : [el];
+    }))))));

package/src/parser/inline/media.ts

@@ -7,7 +7,7 @@ import { unsafehtmlentity } from './htmlentity';
 import { txt, linebreak, str } from '../source';
 import { markInvalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
+import { push } from 'spica/array';
 import { html, define } from 'typed-dom/dom';
 
 const optspec = {
@@ -23,7 +23,11 @@ export const media: MediaParser = lazy(() => constraint(State.media, false, vali
   bind(verify(fmap(tails([
     dup(surround(
       '[',
-      precedence(1, some(union([unsafehtmlentity, bracket, txt]), ']', [['\n', 9]])),
+      precedence(1, some(verify(union([
+        unsafehtmlentity,
+        bracket,
+        txt,
+      ]), ns => ns[0] !== Command.Escape), ']', [['\n', 9]])),
       ']',
       true, undefined, undefined, 1 | Backtrack.media)),
     dup(surround(
@@ -71,13 +75,13 @@ export const linemedia: MediaParser.LineMediaParser = surround(
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.media),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.media),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.media),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.media),
   surround(str('"'), precedence(2, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
-    undefined, undefined, 3 | Backtrack.media),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.media),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([

package/src/parser/inline/reference.ts

@@ -1,5 +1,5 @@
 import { ReferenceParser } from '../inline';
-import { State, Recursion, Backtrack } from '../context';
+import { State, Recursion, Backtrack, BacktrackState } from '../context';
 import { union, subsequence, some, creation, precedence, state, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -19,7 +19,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
     trimBlankNodeEnd(ns).length > 0
       ? [[html('sup', attributes(ns), [html('span', defrag(ns))])], rest]
       : undefined,
-  undefined, 1 | Backtrack.bracket))));
+  undefined, 1 | Backtrack.linebracket, Backtrack.bracket | BacktrackState.nobreak))));
 
 // Chicago-Style
 const abbr: ReferenceParser.AbbrParser = creation(1, Recursion.ignore, surround(

package/src/parser/inline/ruby.ts

@@ -4,7 +4,7 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, creation, surround, lazy, fmap, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { isStartTightNodes } from '../visibility';
+import { isTightNodeStart } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -13,7 +13,7 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
     bind(surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
       const ns = eval(text({ source, context }), [undefined])[0];
       ns && ns.at(-1) === '' && ns.pop();
-      return ns && isStartTightNodes(ns) ? [[ns], rest] : undefined;
+      return ns && isTightNodeStart(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];
@@ -26,7 +26,8 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
         return [
           html('ruby', attributes(texts, rubies), defrag(texts
             .reduce((acc, _, i) =>
-              push(acc, unshift([texts[i]],
+              push(acc, unshift(
+                [texts[i]],
                 i < rubies.length && rubies[i]
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))
@@ -36,7 +37,8 @@ export const ruby: RubyParser = lazy(() => creation(1, Recursion.ignore, fmap(
         return [
           html('ruby', attributes(texts, rubies), defrag([...texts[0]]
             .reduce((acc, _, i, texts) =>
-              push(acc, unshift([texts[i]],
+              push(acc, unshift(
+                [texts[i]],
                 i < rubies.length && rubies[i]
                   ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
                   : [html('rt')]))

package/src/parser/inline/strong.ts

@@ -4,14 +4,14 @@ import { union, some, creation, precedence, surround, open, lazy } from '../../c
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { startTight, blankWith } from '../visibility';
+import { tightStart, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const strong: StrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('**', '*'),
   precedence(0,
-  startTight(some(union([
+  tightStart(some(union([
     some(inline, blankWith('**')),
     open(some(inline, '*'), union([
       emstrong,

package/src/parser/inline/template.ts

@@ -1,13 +1,12 @@
 import { TemplateParser } from '../inline';
-import { Recursion, Backtrack } from '../context';
-import { union, some, creation, precedence, surround, lazy } from '../../combinator';
+import { Recursion, Backtrack, Command } from '../context';
+import { union, some, creation, precedence, verify, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore, surround(
   '{{',
-  precedence(1, some(union([bracket, escsource]), '}')),
+  precedence(1, some(verify(union([bracket, escsource]), ns => ns[0] !== Command.Escape), '}')),
   '}}',
   true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('')}}}`)], rest],
@@ -15,11 +14,11 @@ export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore,
 
 const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.template),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.template),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true,
-    undefined, ([as, bs = []], rest) => [unshift(as, bs), rest], 3 | Backtrack.template),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.template),
   surround(str('"'), precedence(2, some(escsource, /^["\n]/)), str('"'), true,
-    undefined, undefined, 3 | Backtrack.template),
+    undefined, () => [[Command.Escape], ''], 3 | Backtrack.template),
 ])));