securemark 0.256.0 → 0.257.0

package/markdown.d.ts

@@ -1,6 +1,22 @@
 import { Parser, Ctx } from './src/combinator/data/parser';
 import { Dict } from 'spica/dict';
 
+/*
+
+Operator precedence
+
+9: \n, \\\n
+8: `, "
+7: $
+6: (()), [[]]
+5: <tag></tag>
+4: [% %]
+3: (), [], {}
+2: ==, ++, ~~
+1: *, **
+
+*/
+
 declare abstract class Markdown<T> {
   private parser?: T;
 }
@@ -671,7 +687,7 @@ export namespace MarkdownParser {
     export interface AnnotationParser extends
       // ((abc))
       Inline<'annotation'>,
-      Parser<HTMLElement, Context, [
+      Parser<HTMLElement | string, Context, [
         InlineParser,
       ]> {
     }
@@ -680,7 +696,7 @@ export namespace MarkdownParser {
       // [[^abbr]]
       // [[^abbr| abc]]
       Inline<'reference'>,
-      Parser<HTMLElement, Context, [
+      Parser<HTMLElement | string, Context, [
         ReferenceParser.AbbrParser,
         InlineParser,
         InlineParser,
@@ -740,7 +756,6 @@ export namespace MarkdownParser {
         MathParser.BracketParser,
         Parser<string, Context, [
           MathParser.BracketParser,
-          MathParser.QuoteParser,
           SourceParser.StrParser,
         ]>,
       ]> {
@@ -753,14 +768,6 @@ export namespace MarkdownParser {
           SourceParser.EscapableSourceParser,
         ]> {
       }
-      export interface QuoteParser extends
-        Inline<'math/quote'>,
-        Parser<HTMLElement, Context, [
-          QuoteParser,
-          BracketParser,
-          SourceParser.StrParser,
-        ]> {
-      }
     }
     export interface ExtensionParser extends
       // [#abc]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.256.0",
+  "version": "0.257.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

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

@@ -13,7 +13,7 @@ export function guard<T>(f: (context: Ctx) => boolean, parser: Parser<T>): Parse
       : undefined;
 }
 
-export function reset<P extends Parser<unknown>>(context: Context<P>, parser: P): P;
+export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
 export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
@@ -21,7 +21,7 @@ export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
     parser(source, inherit(ObjectCreate(context), base));
 }
 
-export function context<P extends Parser<unknown>>(context: Context<P>, parser: P): P;
+export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
 export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
@@ -57,3 +57,14 @@ const inherit = template((prop, target, source) => {
       return target[prop] = source[prop];
   }
 });
+
+export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
+export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
+  return (source, context) => {
+    const p = context.precedence;
+    context.precedence = precedence;
+    const result = parser(source, context);
+    context.precedence = p;
+    return result;
+  };
+}

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

@@ -7,8 +7,8 @@ export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>
   assert(cost >= 0);
   return (source, context) => {
     const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations.');
-    if (resources.recursion <= 0) throw new Error('Too much recursion.');
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
     const result = parser!(source, context);
     ++resources.recursion;
@@ -18,3 +18,37 @@ export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>
     return result;
   };
 }
+
+export function uncreator<P extends Parser<unknown>>(parser: P): P;
+export function uncreator<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function uncreator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return uncreator(1, cost);
+  assert(cost >= 0);
+  return (source, context) => {
+    const { resources = { budget: 1, recursion: 1 } } = context;
+    if (resources.budget <= 0) throw new Error('Too many creations');
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    ++resources.recursion;
+    const result = parser!(source, context);
+    --resources.recursion;
+    if (result) {
+      resources.budget += cost;
+    }
+    return result;
+  };
+}
+
+export function recursion<P extends Parser<unknown>>(parser: P): P;
+export function recursion<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function recursion(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return recursion(1, cost);
+  assert(cost >= 0);
+  return (source, context) => {
+    const { resources = { recursion: 1 } } = context;
+    if (resources.recursion <= 0) throw new Error('Too much recursion');
+    --resources.recursion;
+    const result = parser!(source, context);
+    ++resources.recursion;
+    return result;
+  };
+}

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

@@ -6,27 +6,27 @@ import { unshift, push } from 'spica/array';
 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>>, optional?: false,
   f?: (rss: [S[], SubTree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubTree<P>[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubTree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
 ): 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>>, optional?: boolean,
   f?: (rss: [S[], SubTree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubTree<P>[] | undefined], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], SubTree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
 ): 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>>, optional?: false,
   f?: (rss: [S[], Tree<P>[], S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Tree<P>[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Tree<P>[], string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
 ): 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>>, optional?: boolean,
   f?: (rss: [S[], Tree<P>[] | undefined, S[]], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Tree<P>[] | undefined], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [S[], Tree<P>[] | undefined, string], rest: string, context: Context<P>) => Result<Tree<P>, Context<P>, SubParsers<P>>,
 ): P;
 export function surround<T>(
   opener: string | RegExp | Parser<T>, parser: Parser<T>, closer: string | RegExp | Parser<T>, optional: boolean = false,
   f?: (rss: [T[], T[], T[]], rest: string, context: Ctx) => Result<T>,
-  g?: (rss: [T[], T[]], rest: string, context: Ctx) => Result<T>,
+  g?: (rss: [T[], T[], string], rest: string, context: Ctx) => Result<T>,
 ): Parser<T> {
   switch (typeof opener) {
     case 'string':
@@ -60,7 +60,7 @@ export function surround<T>(
         ? f([rl, rm!, rr], rest, context)
         : [push(unshift(rl, rm ?? []), rr), rest]
       : g
-        ? g([rl, rm!], rest, context)
+        ? g([rl, rm!, mr_], rest, context)
         : undefined;
   };
 }

package/src/combinator/data/parser/inits.ts

@@ -14,7 +14,7 @@ export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) break;
-      assert(!context?.delimiters?.match(rest));
+      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

package/src/combinator/data/parser/sequence.ts

@@ -14,7 +14,7 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D
       const result = parsers[i](rest, context);
       assert(check(rest, result));
       if (!result) return;
-      assert(!context?.delimiters?.match(rest));
+      assert(!context?.delimiters?.match(rest, context.precedence));
       nodes = nodes
         ? push(nodes, eval(result))
         : eval(result);

package/src/combinator/data/parser/some.ts

@@ -3,6 +3,8 @@ import { Parser, Delimiters, eval, exec, check } from '../parser';
 import { memoize, reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
+type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
+
 const signature = (pattern: string | RegExp | undefined): string => {
   switch (typeof pattern) {
     case 'undefined':
@@ -26,31 +28,29 @@ const matcher = memoize(
   },
   signature);
 
-export function some<P extends Parser<unknown>>(parser: P, until?: string | RegExp | number, deep?: string | RegExp, limit?: number): P;
-export function some<T>(parser: Parser<T>, until?: string | RegExp | number, deep?: string | RegExp, limit = -1): Parser<T> {
+export function some<P extends Parser<unknown>>(parser: P, until?: string | RegExp | number, deeps?: readonly DelimiterOption[], limit?: number): P;
+export function some<T>(parser: Parser<T>, until?: string | RegExp | number, deeps: readonly DelimiterOption[] = [], limit = -1): Parser<T> {
+  if (typeof until === 'number') return some(parser, undefined, deeps, until);
   assert(parser);
-  assert(until instanceof RegExp ? !until.flags.match(/[gmy]/) && until.source.startsWith('^') : true);
-  assert(deep instanceof RegExp ? !deep.flags.match(/[gmy]/) && deep.source.startsWith('^') : true);
-  if (typeof until === 'number') return some(parser, undefined, deep, until);
+  assert([until].concat(deeps.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
   const match = matcher(until);
-  const delimiter = {
-    signature: signature(deep),
-    matcher: matcher(deep),
-  } as const;
+  const delimiters = deeps.map(([delimiter, precedence]) => ({
+    signature: signature(delimiter),
+    matcher: matcher(delimiter),
+    precedence,
+  }));
   return (source, context) => {
     if (source === '') return;
     let rest = source;
     let nodes: T[] | undefined;
-    if (deep && context) {
-      // bracket > link > media | bracket
-      // bracket > index > bracket
+    if (delimiters.length > 0) {
       context.delimiters ??= new Delimiters();
-      context.delimiters.push(delimiter);
+      context.delimiters.push(...delimiters);
     }
     while (true) {
       if (rest === '') break;
       if (match(rest)) break;
-      if (context.delimiters?.match(rest)) break;
+      if (context.delimiters?.match(rest, context.precedence)) break;
       const result = parser(rest, context);
       assert.doesNotThrow(() => limit < 0 && check(rest, result));
       if (!result) break;
@@ -60,8 +60,8 @@ export function some<T>(parser: Parser<T>, until?: string | RegExp | number, dee
       rest = exec(result);
       if (limit >= 0 && source.length - rest.length > limit) break;
     }
-    if (deep && context.delimiters) {
-      context.delimiters.pop();
+    if (delimiters.length > 0) {
+      context.delimiters!.pop(delimiters.length);
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length
@@ -69,25 +69,3 @@ export function some<T>(parser: Parser<T>, until?: string | RegExp | number, dee
       : undefined;
   };
 }
-
-export function escape<P extends Parser<unknown>>(parser: P, delim: string): P;
-export function escape<T>(parser: Parser<T>, delim: string): Parser<T> {
-  assert(parser);
-  const delimiter = {
-    signature: signature(delim),
-    matcher: (source: string) => source.slice(0, delim.length) !== delim && undefined,
-    escape: true,
-  } as const;
-  return (source, context) => {
-    if (source === '') return;
-    if (context) {
-      context.delimiters ??= new Delimiters();
-      context.delimiters.push(delimiter);
-    }
-    const result = parser(source, context);
-    if (context.delimiters) {
-      context.delimiters.pop();
-    }
-    return result;
-  };
-}

package/src/combinator/data/parser.ts

@@ -1,5 +1,3 @@
-import { undefined } from 'spica/global';
-
 export type Parser<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = (source: string, context: C) => Result<T, C, D>;
 export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
@@ -11,6 +9,7 @@ export interface Ctx {
     budget: number;
     recursion: number;
   };
+  precedence?: number;
   delimiters?: Delimiters;
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;
@@ -22,28 +21,44 @@ type ExtractSubTree<D extends Parser<unknown>[]> = ExtractSubParser<D> extends i
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
 export class Delimiters {
-  private readonly matchers: ((source: string) => boolean | undefined)[] = [];
-  private readonly record: Record<string, boolean> = {};
-  public push(delimiter: { readonly signature: string; readonly matcher: (source: string) => boolean | undefined; readonly escape?: boolean; }): void {
-    const { signature, matcher, escape } = delimiter;
-    if (this.record[signature] === !escape) {
-      this.matchers.unshift(() => undefined);
-    }
-    else {
-      this.matchers.unshift(matcher);
-      this.record[signature] = !escape;
+  private readonly matchers: [number, string, number, (source: string) => boolean | undefined][] = [];
+  private readonly registry: Record<string, boolean> = {};
+  private length = 0;
+  public push(
+    ...delimiters: readonly {
+      readonly signature: string;
+      readonly matcher: (source: string) => boolean | undefined;
+      readonly precedence?: number;
+    }[]
+  ): void {
+    for (let i = 0; i < delimiters.length; ++i) {
+      const delimiter = delimiters[i];
+      assert(this.length >= this.matchers.length);
+      const { signature, matcher, precedence = 1 } = delimiter;
+      if (!this.registry[signature]) {
+        this.matchers.unshift([this.length, signature, precedence, matcher]);
+        this.registry[signature] = true;
+      }
+      ++this.length;
     }
   }
-  public pop(): void {
-    assert(this.matchers.length > 0);
-    this.matchers.shift();
+  public pop(count = 1): void {
+    assert(count > 0);
+    for (let i = 0; i < count; ++i) {
+      assert(this.matchers.length > 0);
+      assert(this.length >= this.matchers.length);
+      if (--this.length === this.matchers[0][0]) {
+        this.registry[this.matchers.shift()![1]] = false;
+      }
+    }
   }
-  public match(source: string): boolean {
+  public match(source: string, precedence = 1): boolean {
     const { matchers } = this;
     for (let i = 0; i < matchers.length; ++i) {
-      switch (matchers[i](source)) {
+      switch (matchers[i][3](source)) {
         case true:
-          return true;
+          if (precedence < matchers[i][2]) return true;
+          continue;
         case false:
           return false;
       }
@@ -73,6 +88,7 @@ export function exec(result: Result<unknown>, default_?: string): string | undef
 
 export function check(source: string, result: Result<unknown>, mustConsume = true): true {
   assert.doesNotThrow(() => {
+    if (source.length > 1000) return;
     if (source.slice(+mustConsume).slice(-exec(result, '').length || source.length) !== exec(result, '')) throw new Error();
   });
   return true;

package/src/debug.test.ts

@@ -4,8 +4,8 @@ import { querySelector, querySelectorAll } from 'typed-dom/query';
 
 export function inspect(result: Result<HTMLElement | string>, until: number | string = Infinity): Result<string> {
   return result && [
-    eval(result).map(node => {
-      assert(node);
+    eval(result).map((node, i, nodes) => {
+      assert(node || node === '' && '([{'.includes(nodes[i + 1] as string));
       if (typeof node === 'string') return node;
       node = node.cloneNode(true);
       assert(!querySelector(node, '.invalid[data-invalid-message$="."]'));

package/src/parser/api/bind.ts

@@ -1,5 +1,4 @@
 import { undefined, location } from 'spica/global';
-import { ObjectAssign, ObjectCreate } from 'spica/alias';
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { eval } from '../../combinator/data/parser';
@@ -21,11 +20,10 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   nearest: (position: number) => HTMLElement | undefined;
   index: (block: HTMLElement) => number;
 } {
-  const context: MarkdownParser.Context = ObjectAssign(ObjectCreate(settings), {
+  let context: MarkdownParser.Context = {
+    ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-    footnotes: undefined,
-    chunk: undefined,
-  });
+  };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   assert(!settings.id);
   type Block = readonly [segment: string, blocks: readonly HTMLElement[], url: string];
@@ -41,14 +39,14 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   };
 
   function* parse(source: string): Generator<Progress, undefined, undefined> {
-    if (settings.chunk && revision) throw new Error('Chunks cannot be updated.');
+    if (settings.chunk && revision) throw new Error('Chunks cannot be updated');
     const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
     source = normalize(validate(source, MAX_INPUT_SIZE) ? source : source.slice(0, MAX_INPUT_SIZE + 1));
-    ObjectAssign<MarkdownParser.Context, MarkdownParser.Context>(
-      context,
-      {
-        url: url ? new ReadonlyURL(url as ':') : undefined,
-      });
+    // Change the object identity.
+    context = {
+      ...context,
+      url: url ? new ReadonlyURL(url as ':') : undefined,
+    };
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
     for (const seg of segment(source)) {

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

@@ -223,27 +223,64 @@ describe('Unit: parser/api/parse', () => {
         ['<p>a<span class="linebreak"> </span>b</p>']);
     });
 
-    it('creation', () => {
+    it('backtrack', () => {
       assert.deepStrictEqual(
-        [...parse('"[% '.repeat(100)).children].map(el => el.outerHTML),
-        [`<p>${'"[% '.repeat(100).trim()}</p>`]);
+        [...parse('"[% '.repeat(100) + '\n\na').children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'"[% '.repeat(100)}\n</pre>`,
+          '<p>a</p>',
+        ]);
+    });
+
+    it('recursion', () => {
+      assert.deepStrictEqual(
+        [...parse('('.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'('.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('('.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'('.repeat(21)}</pre>`,
+        ]);
+      assert.deepStrictEqual(
+        [...parse('['.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'['.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('['.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'['.repeat(21)}</pre>`,
+        ]);
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(20)).children].map(el => el.outerHTML),
+        [`<p>${'{'.repeat(20)}</p>`]);
+      assert.deepStrictEqual(
+        [...parse('{'.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [
+          '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
+          `<pre class="error" translate="no">${'{'.repeat(21)}</pre>`,
+        ]);
     });
 
     if (!navigator.userAgent.includes('Chrome')) return;
 
-    it('recursion', () => {
+    it('creation', function () {
+      this.timeout(5000);
+      // 実測500ms程度
       assert.deepStrictEqual(
-        [...parse('('.repeat(199)).children].map(el => el.outerHTML),
-        [`<p>${'('.repeat(199)}</p>`]);
+        [...parse('.'.repeat(50000)).children].map(el => el.outerHTML),
+        [`<p>${'.'.repeat(50000)}</p>`]);
     });
 
-    it('recursion error', () => {
+    it('creation error', function () {
+      this.timeout(5000);
+      // 実測500ms程度
       assert.deepStrictEqual(
-        [...parse('('.repeat(200) + '\n\na').children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('.'.repeat(50001)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
-          '<h1 id="error:rnd" class="error">Error: Too much recursion.</h1>',
-          `<pre class="error" translate="no">${'('.repeat(200)}\n</pre>`,
-          '<p>a</p>',
+          '<h1 id="error:rnd" class="error">Error: Too many creations</h1>',
+          `<pre class="error" translate="no">${'.'.repeat(1000).slice(0, 997)}...</pre>`,
         ]);
     });
 

package/src/parser/block.ts

@@ -36,7 +36,7 @@ export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
 export const block: BlockParser = creator(error(
-  reset({ resources: { budget: 50 * 1000, recursion: 200 } },
+  reset({ resources: { budget: 50 * 1000, recursion: 20 + 1 } },
   union([
     emptyline,
     horizontalrule,

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

@@ -17,11 +17,11 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\\na))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\n))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\nb))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\n))')), [['(('], 'a\n))']);
+      assert.deepStrictEqual(inspect(parser('((a\\\n))')), [['(('], 'a\\\n))']);
+      assert.deepStrictEqual(inspect(parser('((a\nb))')), [['(('], 'a\nb))']);
+      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), [['(('], 'a\\\nb))']);
+      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), [['(('], '*a\nb*))']);
       assert.deepStrictEqual(inspect(parser('((\\))')), undefined);
       assert.deepStrictEqual(inspect(parser('((a)b))')), undefined);
       assert.deepStrictEqual(inspect(parser('(((a))')), undefined);
@@ -42,6 +42,7 @@ describe('Unit: parser/inline/annotation', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((`a`))')), [['<sup class="annotation"><span><code data-src="`a`">a</code></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((@a))')), [['<sup class="annotation"><span><a href="/@a" class="account">@a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((http://host))')), [['<sup class="annotation"><span><a href="http://host" target="_blank">http://host</a></span></sup>'], '']);

package/src/parser/inline/annotation.ts

@@ -1,11 +1,12 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, validate, guard, context, creator, surround, lazy, fmap } from '../../combinator';
+import { union, some, validate, guard, context, precedence, creator, recursion, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { optimize } from './reference';
 import { trimBlankStart, trimNodeEnd } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => creator(validate('((', fmap(surround(
+export const annotation: AnnotationParser = lazy(() => creator(recursion(precedence(6, validate('((', surround(
   '((',
   guard(context => context.syntax?.inline?.annotation ?? true,
   context({ syntax: { inline: {
@@ -19,6 +20,8 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', fm
     //link: true,
     //autolink: true,
   }}, delimiters: undefined },
-  trimBlankStart(some(union([inline]), ')', /^\\?\n/)))),
-  '))'),
-  ns => [html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])]))));
+  trimBlankStart(some(union([inline]), ')', [[/^\\?\n/, 9], [')', 3], ['))', 6]])))),
+  '))',
+  false,
+  ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))))));

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

@@ -1,7 +1,8 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, validate, focus, rewrite, context, creator, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, validate, focus, rewrite, precedence, creator, convert, surround, open, lazy } from '../../../combinator';
 import { link } from '../link';
 import { unescsource } from '../../source';
+import { clean } from '../../util';
 
 const closer = /^[-+*=~^,.;:!?]*(?=["`|\[\](){}<>]|\\?$)/;
 
@@ -9,14 +10,13 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
   open(
     /^https?:\/\/(?=[\x21-\x7E])/,
     focus(/^[\x21-\x7E]+/, some(union([bracket, some(unescsource, closer)])))),
-  context({ syntax: { inline: { link: true } } },
   convert(
     url => `{ ${url} }`,
-    union([link]))))));
+    clean(union([link]))))));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(3, union([
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),
-  surround('"', some(unescsource, '"'), '"', true),
-])));
+  surround('"', precedence(8, some(unescsource, '"')), '"', true),
+]))));