securemark 0.289.4 → 0.289.6

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

@@ -7,7 +7,6 @@ export function surround<P extends Parser<unknown>, S = string>(
   f?: (rss: [S[], SubNode<P>[], S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], SubNode<P>[], string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
@@ -15,7 +14,6 @@ export function surround<P extends Parser<unknown>, S = string>(
   f?: (rss: [S[], SubNode<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], SubNode<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
@@ -23,7 +21,6 @@ export function surround<P extends Parser<unknown>, S = string>(
   f?: (rss: [S[], Node<P>[], S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], Node<P>[], string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  backtrackstate?: number,
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
@@ -31,7 +28,6 @@ export function surround<P extends Parser<unknown>, S = string>(
   f?: (rss: [S[], Node<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [S[], Node<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
-  backtrackstate?: number,
 ): P;
 export function surround<N>(
   opener: string | RegExp | Parser<N>, parser: Parser<N>, closer: string | RegExp | Parser<N>,
@@ -39,7 +35,6 @@ export function surround<N>(
   f?: (rss: [N[], N[], N[]], rest: string, context: Ctx) => Result<N>,
   g?: (rss: [N[], N[], string], rest: string, context: Ctx) => Result<N>,
   backtracks: readonly number[] = [],
-  backtrackstate: number = 0,
 ): Parser<N> {
   switch (typeof opener) {
     case 'string':
@@ -51,7 +46,6 @@ export function surround<N>(
     case 'object':
       closer = match(closer);
   }
-  const statesize = 2;
   return ({ source, context }) => {
     const sme_ = source;
     if (sme_ === '') return;
@@ -62,41 +56,18 @@ export function surround<N>(
     if (resultS === undefined) return void revert(context, linebreak);
     const nodesS = eval(resultS);
     const me_ = exec(resultS);
-    for (const backtrack of backtracks) {
-      if (backtrack & 1) {
-        const { backtracks = {}, backtrack: state = 0, offset = 0 } = context;
-        for (let i = 0; i < source.length - me_.length; ++i) {
-          if (source[i] !== source[0]) break;
-          const pos = source.length - i + offset - 1;
-          assert(pos >= 0);
-          if (!(pos in backtracks)) continue;
-          const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
-          if (backtracks[pos] & 1 << size(backtrack >>> statesize) + shift) return void revert(context, linebreak);
-        }
-      }
-    }
-    const { backtrack = 0 } = context;
-    context.backtrack = backtrack | backtrackstate;
+    if (getBacktrack(context, backtracks, sme_, sme_.length - me_.length)) return void revert(context, linebreak);
     const resultM = me_ !== '' ? parser({ source: me_, context }) : undefined;
     assert(check(me_, resultM));
-    context.backtrack = backtrack;
     const nodesM = eval(resultM);
     const e_ = exec(resultM, me_);
-    if (!nodesM && !optional) return void revert(context, linebreak);
-    const resultE = closer({ source: e_, context });
+    const resultE = nodesM || optional ? closer({ source: e_, context }) : undefined;
     assert(check(e_, resultE, false));
     const nodesE = eval(resultE);
     const rest = exec(resultE, e_);
+    nodesE || setBacktrack(context, backtracks, sme_.length);
+    if (!nodesM && !optional) return void revert(context, linebreak);
     if (rest.length === sme_.length) return void revert(context, linebreak);
-    for (const backtrack of backtracks) {
-      if (backtrack & 2 && nodesE === undefined) {
-        const { backtracks = {}, backtrack: state = 0, offset = 0 } = context;
-        const pos = source.length + offset - 1;
-        assert(pos >= 0);
-        const shift = backtrack >>> statesize & state >>> statesize ? state & (1 << statesize) - 1 : 0;
-        backtracks[pos] |= 1 << size(backtrack >>> statesize) + shift;
-      }
-    }
     context.recent = [
       sme_.slice(0, sme_.length - me_.length),
       me_.slice(0, me_.length - e_.length),
@@ -118,13 +89,72 @@ export function surround<N>(
     return result;
   };
 }
-export function open<P extends Parser<unknown>>(opener: string | RegExp | Parser<Node<P>, Context<P>>, parser: P, optional?: boolean): P;
-export function open<N>(opener: string | RegExp | Parser<N>, parser: Parser<N>, optional = false): Parser<N> {
-  return surround(opener, parser, '', optional);
+export function open<P extends Parser<unknown>>(
+  opener: string | RegExp | Parser<Node<P>, Context<P>>,
+  parser: P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function open<N>(
+  opener: string | RegExp | Parser<N>,
+  parser: Parser<N>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): Parser<N> {
+  return surround(opener, parser, '', optional, undefined, undefined, backtracks);
+}
+export function close<P extends Parser<unknown>>(
+  parser: P,
+  closer: string | RegExp | Parser<Node<P>, Context<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function close<N>(
+  parser: Parser<N>,
+  closer: string | RegExp | Parser<N>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): Parser<N> {
+  return surround('', parser, closer, optional, undefined, undefined, backtracks);
+}
+
+const statesize = 2;
+export function getBacktrack(
+  context: Ctx,
+  backtracks: readonly number[],
+  source: string,
+  length: number,
+): boolean {
+  for (const backtrack of backtracks) {
+    if (backtrack & 1) {
+      const { backtracks = {}, offset = 0 } = context;
+      for (let i = 0; i < length; ++i) {
+        if (source[i] !== source[0]) break;
+        const pos = source.length - i + offset - 1;
+        assert(pos >= 0);
+        if (!(pos in backtracks)) continue;
+        if (backtracks[pos] & 1 << size(backtrack >>> statesize)) return true;
+      }
+    }
+  }
+  return false;
 }
-export function close<P extends Parser<unknown>>(parser: P, closer: string | RegExp | Parser<Node<P>, Context<P>>, optional?: boolean): P;
-export function close<N>(parser: Parser<N>, closer: string | RegExp | Parser<N>, optional: boolean = false): Parser<N> {
-  return surround('', parser, closer, optional);
+export function setBacktrack(
+  context: Ctx,
+  backtracks: readonly number[],
+  position: number,
+  length: number = 1,
+): void {
+  for (const backtrack of backtracks) {
+    if (backtrack & 2) {
+      const { backtracks = {}, offset = 0 } = context;
+      for (let i = 0; i < length; ++i) {
+        const pos = position - i + offset - 1;
+        assert(pos >= 0);
+        backtracks[pos] |= 1 << size(backtrack >>> statesize);
+      }
+    }
+  }
 }
 
 function match(pattern: string | RegExp): (input: Input) => [never[], string] | undefined {

package/src/combinator/control/monad/bind.ts

@@ -12,6 +12,7 @@ export function bind<N, U>(parser: Parser<N>, f: (nodes: N[], rest: string, cont
     const res1 = parser(input);
     assert(check(source, res1));
     if (res1 === undefined) return;
+    context.recent = [source.slice(0, source.length - exec(res1).length)];
     const res2 = f(eval(res1), exec(res1), context);
     assert(check(source, res2));
     assert(check(exec(res1), res2, false));

package/src/combinator/data/parser.ts

@@ -21,7 +21,6 @@ export interface Ctx {
   state?: number;
   depth?: number;
   backtracks?: Record<number, number>;
-  backtrack?: number;
   linebreak?: number;
   recent?: string[];
 }

package/src/parser/api/parse.test.ts

@@ -350,20 +350,21 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(5 + 0)}{{(([[[http://${'['.repeat(13)}${'.'.repeat(8323)}`;
+      // 8n = template + link + annotation/reference + link + code + url + ruby + text
+      const source = `${'.'.repeat(1 + 0)}{{(([[[\`http://[${'.'.repeat(12493)}`;
       assert.deepStrictEqual(
-        [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
-        [`<p>${str}</p>`]);
+        [...parse(source).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [`<p>${source}</p>`]);
     });
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const str = `${'.'.repeat(5 + 1)}{{(([[[http://${'['.repeat(13)}${'.'.repeat(8323)}`;
+      const source = `${'.'.repeat(1 + 1)}{{(([[[\`http://[${'.'.repeat(12493)}`;
       assert.deepStrictEqual(
-        [...parse(str).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse(source).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
           '<h1 id="error:rnd" class="error">Error: Too many creations</h1>',
-          `<pre class="error" translate="no">${str.slice(0, 1000 - 3)}...</pre>`,
+          `<pre class="error" translate="no">${source.slice(0, 1000 - 3)}...</pre>`,
         ]);
     });
 

package/src/parser/context.ts

@@ -28,18 +28,12 @@ export const enum Recursion {
 }
 
 export const enum Backtrack {
-  link = 1 << 7,
-  ruby = 1 << 6,
-  linedoublebracket = 1 << 5,
-  linebracket = 1 << 4,
+  link = 1 << 6,
+  ruby = 1 << 5,
+  doublebracket = 1 << 4,
   bracket = 1 << 3,
-  lineescbracket = 1 << 2,
-  lineunescbracket = 0 << 2,
-}
-// バックトラックを削減するため括弧派生構文を改行禁止し
-// 括弧派生構文内のバックトラック状態を統一する。
-export const enum BacktrackState {
-  nobreak = 1,
+  escbracket = 1 << 2,
+  autolink = 0 << 2,
 }
 
 export const enum Command {

package/src/parser/inline/annotation.ts

@@ -1,5 +1,5 @@
 import { AnnotationParser } from '../inline';
-import { State, Backtrack, BacktrackState } from '../context';
+import { State, Backtrack } from '../context';
 import { union, some, precedence, state, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
@@ -8,13 +8,13 @@ import { html, defrag } from 'typed-dom/dom';
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, false, surround(
   '((',
   precedence(1, state(State.annotation | State.media,
-  trimBlankStart(some(union([inline]), ')', [['\n', 9], [')', 1]])))),
+  trimBlankStart(some(union([inline]), ')', [[')', 1]])))),
   '))',
   false,
-  ([, ns], rest) =>
+  ([, ns], rest, context) =>
+    context.linebreak === undefined &&
     trimBlankNodeEnd(ns).length > 0
       ? [[html('sup', { class: 'annotation' }, [html('span', defrag(ns))])], rest]
       : undefined,
   undefined,
-  [3 | Backtrack.linedoublebracket, 1 | Backtrack.linebracket],
-  Backtrack.bracket | BacktrackState.nobreak)));
+  [3 | Backtrack.doublebracket, 1 | Backtrack.bracket])));

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

@@ -1,14 +1,20 @@
 import { AutolinkParser } from '../../inline';
-import { State } from '../../context';
-import { union, state, constraint, verify, rewrite } from '../../../combinator';
+import { State, Backtrack } from '../../context';
+import { union, state, constraint, verify, rewrite, surround } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 
 // https://html.spec.whatwg.org/multipage/input.html
 
-export const email: AutolinkParser.EmailParser = rewrite(verify(
-  str(/^[0-9a-z](?:[_.+-](?=[0-9a-z])|[0-9a-z]){0,255}@[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?(?:\.[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?)*(?![0-9a-z])/i),
-  ([source]) => source.length <= 255),
+export const email: AutolinkParser.EmailParser = rewrite(
+  surround(
+    str(/^[0-9a-z]/i),
+    verify(
+      str(/^(?:[_.+-](?=[0-9a-z])|[0-9a-z]){0,255}@[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?(?:\.[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?)*(?![0-9a-z])/i),
+      ([source]) => source.length <= 255 - 1),
+    '',
+    false, undefined, undefined,
+    [3 | Backtrack.autolink]),
   union([
     constraint(State.autolink, false, state(State.autolink,
       ({ source }) => [[html('a', { class: 'email', href: `mailto:${source}` }, source)], ''])),

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

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { State } from '../../context';
+import { State, Backtrack } from '../../context';
 import { union, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -16,7 +16,9 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => rewrite(
     str(new RegExp([
       /^(?!['_])(?=(?:[0-9]{1,9})?(?:[^\d\p{C}\p{S}\p{P}\s]|emoji|'(?=[0-9A-Za-z])|_(?=[^'\p{C}\p{S}\p{P}\s]|emoji)))/u.source,
       /(?:[^\p{C}\p{S}\p{P}\s]|emoji|'(?=[0-9A-Za-z])|_(?=[^'\p{C}\p{S}\p{P}\s]|emoji))+/u.source,
-    ].join('').replace(/emoji/g, emoji), 'u'))),
+    ].join('').replace(/emoji/g, emoji), 'u')),
+    false,
+    [3 | Backtrack.autolink]),
   union([
     constraint(State.autolink, false, state(State.autolink, fmap(convert(
       source => `[${source}]{ ${`/hashtags/${source.slice(1)}`} }`,

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

@@ -4,15 +4,17 @@ import { union, tails, some, recursion, precedence, state, constraint, validate,
 import { unsafelink } from '../link';
 import { linebreak, unescsource, str } from '../../source';
 
-const closer = /^[-+*=~^_,.;:!?]*(?=[\\"`|\[\](){}<>]|$)/;
+const closer = /^[-+*=~^_,.;:!?]*(?=[\\"`|\[\](){}<>]|[^\x21-\x7E]|$)/;
 
 export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'https://'], rewrite(
   open(
     /^https?:\/\/(?=[\x21-\x7E])/,
-    focus(/^[\x21-\x7E]+/, precedence(1, some(union([
+    precedence(1, some(union([
       verify(bracket, ns => ns.length > 0),
       some(unescsource, closer),
-    ]))))),
+    ]), undefined, [[/^[^\x21-\x7E]/, 3]])),
+    false,
+    [3 | Backtrack.autolink]),
   union([
     constraint(State.autolink, false, state(State.autolink, convert(
       url => `{ ${url} }`,
@@ -34,15 +36,17 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => open(
           false))),
         ({ source }) => [[source], ''],
       ]),
-    ]))));
+    ])),
+  false,
+  [3 | Backtrack.autolink]));
 
 const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, unescsource]), ')')), str(')'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineunescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.autolink]),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, unescsource]), ']')), str(']'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineunescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.autolink]),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, unescsource]), '}')), str('}'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineunescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.autolink]),
   surround(str('"'), precedence(2, recursion(Recursion.terminal, some(unescsource, '"'))), str('"'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineunescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.autolink]),
 ]));

package/src/parser/inline/code.ts

@@ -1,12 +1,19 @@
 import { CodeParser } from '../inline';
-import { match } from '../../combinator';
+import { validate, getBacktrack, setBacktrack, match } from '../../combinator';
+import { Backtrack } from '../context';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = match(
-  /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,
-  ([whole, , body]) => ({ source }) =>
-    [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)],
-  true);
+export const code: CodeParser = validate(
+  ({ source, context }) =>
+    source[0] === '`' &&
+    !getBacktrack(context, [1 | Backtrack.bracket], source, source.length - 1),
+  match(
+    /^(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|$|\n)/,
+    ([whole, , body, closer]) => ({ source, context }) =>
+      closer
+        ? [[html('code', { 'data-src': whole }, format(body))], source.slice(whole.length)]
+        : void setBacktrack(context, [2 | Backtrack.bracket], source.length),
+    true));
 
 function format(text: string): string {
   assert(text.length > 0);

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../inline';
-import { State, Backtrack, BacktrackState, Command } from '../../context';
+import { State, Backtrack, Command } from '../../context';
 import { eval } from '../../../combinator/data/parser';
 import { union, inits, some, precedence, state, constraint, validate, surround, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
@@ -19,16 +19,16 @@ export const index: IndexParser = lazy(() => constraint(State.index, false, fmap
   some(inits([
     inline,
     signature,
-  ]), ']', [['\n', 9], [']', 1]])))),
+  ]), ']', [[']', 1]])))),
   ']',
   false,
-  ([, ns], rest) =>
+  ([, ns], rest, context) =>
+    context.linebreak === undefined &&
     trimBlankNodeEnd(ns).length > 0
       ? [[html('a', { 'data-index': dataindex(ns) }, defrag(ns))], rest]
       : undefined,
   undefined,
-  [3 | Backtrack.linebracket],
-  Backtrack.bracket | BacktrackState.nobreak)),
+  [3 | Backtrack.bracket])),
   ([el]: [HTMLAnchorElement]) => [
     define(el,
       {

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

@@ -13,7 +13,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(union([
 
 export const label: ExtensionParser.LabelParser = constraint(State.label, false, fmap(
   union([
-    surround('[', body, ']', false, undefined, undefined, [1 | Backtrack.linebracket, 1]),
+    surround('[', body, ']', false, undefined, undefined, [1 | Backtrack.bracket, 1]),
     body,
   ]),
   ([text]) => [

package/src/parser/inline/html.ts

@@ -1,5 +1,5 @@
 import { HTMLParser } from '../inline';
-import { Recursion } from '../context';
+import { Recursion, Backtrack } from '../context';
 import { union, subsequence, some, recursion, precedence, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
@@ -30,13 +30,17 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\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]),
+        [[elem(as[0].slice(1), push(unshift(as, bs), cs), [], [])], rest],
+      undefined,
+      [3 | Backtrack.bracket]),
     match(
       new RegExp(String.raw`^<(${TAGS.join('|')})(?=[^\S\n]|>)`),
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
-          surround(str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
+          surround(
+            str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true,
+            undefined, undefined, [3 | Backtrack.bracket]),
           precedence(3, recursion(Recursion.inline,
           subsequence([
             focus(/^[^\S\n]*\n/, some(inline)),
@@ -54,7 +58,9 @@ export const html: HTMLParser = lazy(() => validate(/^<[a-z]+(?=[^\S\n]|>)/i,
       memoize(
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
-          surround(str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
+          surround(
+            str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true,
+            undefined, undefined, [3 | Backtrack.bracket]),
           precedence(3, recursion(Recursion.inline,
           subsequence([
             focus(/^[^\S\n]*\n/, some(inline)),

package/src/parser/inline/link.ts

@@ -1,13 +1,14 @@
 import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
-import { State, 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 { State, Backtrack, Command } from '../context';
+import { union, inits, tails, sequence, subsequence, some, creation, precedence, state, constraint, validate, surround, open, setBacktrack, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
+import { push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 const optspec = {
@@ -17,22 +18,36 @@ Object.setPrototypeOf(optspec, null);
 
 export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.link, false, creation(10,
   precedence(1, state(State.linkers | State.media,
-  bind(reverse(tails([
+  bind(subsequence([
     dup(surround(
       '[',
-      trimBlankStart(some(union([inline]), ']', [['\n', 9], [']', 1]])),
+      trimBlankStart(some(union([inline]), ']', [[']', 1]])),
       ']',
-      true, undefined, undefined,
-      [1 | Backtrack.linebracket],
-      Backtrack.bracket | BacktrackState.nobreak)),
+      true,
+      ([, ns = []], rest, context) =>
+        context.linebreak === undefined
+          ? [push(ns, [Command.Escape]), rest]
+          : undefined,
+      undefined,
+      [3 | Backtrack.link, 3 | Backtrack.bracket])),
     dup(surround(
       /^{(?![{}])/,
       inits([uri, some(option)]),
       /^[^\S\n]*}/,
       false, undefined, undefined,
       [3 | Backtrack.link])),
-  ])),
-  ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
+  ]),
+  ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
+    if (content.at(-1) === Command.Escape) {
+      content.pop();
+      if (params === undefined) {
+        return void setBacktrack(context, [2 | Backtrack.link], context.recent!.reduce((a, b) => a + b.length, 0));
+      }
+    }
+    else {
+      params = content as string[];
+      content = [];
+    }
     assert(!html('div', content).querySelector('a, .media, .annotation, .reference'));
     assert(content[0] !== '');
     if (content.length !== 0 && trimBlankNodeEnd(content).length === 0) return;

package/src/parser/inline/media.ts

@@ -27,10 +27,15 @@ export const media: MediaParser = lazy(() => constraint(State.media, false, vali
         unsafehtmlentity,
         bracket,
         txt,
-      ]), ']', [['\n', 9]])),
+      ]), ']')),
       ']',
-      true, undefined, undefined,
-      [3 | Backtrack.lineescbracket])),
+      true,
+      ([, ns = []], rest, context) =>
+        context.linebreak === undefined
+          ? [ns, rest]
+          : undefined,
+      undefined,
+      [3 | Backtrack.escbracket])),
     dup(surround(
       /^{(?![{}])/,
       inits([uri, some(option)]),
@@ -77,13 +82,13 @@ export const linemedia: MediaParser.LineMediaParser = surround(
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
   surround(str('"'), precedence(2, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
-    undefined, () => [[], ''], [3 | Backtrack.lineescbracket]),
+    undefined, () => [[], ''], [3 | Backtrack.escbracket]),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([

package/src/parser/inline/reference.ts

@@ -1,6 +1,6 @@
 import { ReferenceParser } from '../inline';
-import { State, Backtrack, BacktrackState } from '../context';
-import { union, subsequence, some, precedence, state, constraint, surround, lazy } from '../../combinator';
+import { State, Backtrack, Command } from '../context';
+import { union, subsequence, some, precedence, state, constraint, surround, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { blank, trimBlankStart, trimBlankNodeEnd } from '../visibility';
@@ -13,20 +13,24 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   precedence(1, state(State.annotation | State.reference | State.media,
   subsequence([
     abbr,
-    trimBlankStart(some(inline, ']', [['\n', 9], [']', 1]])),
+    trimBlankStart(some(inline, ']', [[']', 1]])),
   ]))),
   ']]',
   false,
-  ([, ns], rest) =>
+  ([, ns], rest, context) =>
+    context.linebreak === undefined &&
     trimBlankNodeEnd(ns).length > 0
       ? [[html('sup', attributes(ns), [html('span', defrag(ns))])], rest]
       : undefined,
-  ([as, bs], rest, { state = 0 }) =>
-    state & State.annotation
+  ([as, bs], rest, context) => {
+    if (rest[0] !== ']') {
+      setBacktrack(context, [2 | Backtrack.bracket], context.recent!.reduce((a, b) => a + b.length, 0), 2);
+    }
+    return context.state! & State.annotation
       ? [unshift(as, bs), rest]
-      : undefined,
-  [3 | Backtrack.linedoublebracket, 1 | Backtrack.linebracket],
-  Backtrack.bracket | BacktrackState.nobreak)));
+      : undefined;
+  },
+  [3 | Backtrack.doublebracket, 1 | Backtrack.bracket])));
 
 // Chicago-Style
 const abbr: ReferenceParser.AbbrParser = surround(
@@ -34,14 +38,14 @@ const abbr: ReferenceParser.AbbrParser = surround(
   union([str(/^(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/)]),
   /^\|?(?=]])|^\|[^\S\n]*/,
   true,
-  ([, ns], rest) => ns ? [['\n', ns[0].trimEnd()], rest.replace(blank.start, '')] : [[''], `^${rest}`],
+  ([, ns], rest) => ns ? [[Command.Escape, ns[0].trimEnd()], rest.replace(blank.start, '')] : [[''], `^${rest}`],
   ([, , rest]) => [[''], `^${rest}`]);
 
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   switch (ns[0]) {
     case '':
       return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
-    case '\n':
+    case Command.Escape:
       const abbr = ns[1] as string;
       ns[0] = ns[1] = '';
       return { class: 'reference', 'data-abbr': abbr };