securemark 0.299.1 → 0.299.3

package/markdown.d.ts

@@ -1082,7 +1082,7 @@ export namespace MarkdownParser {
         Inline<'url'>,
         Parser<string | HTMLElement, Context, [
           Parser<HTMLAnchorElement, Context, []>,
-          InlineParser,
+          Parser<string, Context, []>,
         ]> {
       }
       export namespace UrlParser {
@@ -1092,7 +1092,7 @@ export namespace MarkdownParser {
             SourceParser.StrParser,
             Parser<string | HTMLElement, Context, [
               Parser<HTMLAnchorElement, Context, []>,
-              SourceParser.StrParser,
+              Parser<string, Context, []>,
             ]>,
           ]> {
         }

package/package.json

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

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

@@ -1,5 +1,5 @@
 import { Parser, List, Node, Context, failsafe } from '../../data/parser';
-import { consume } from '../../../combinator';
+import { spend } from '../../../combinator';
 import { firstline, isEmptyline } from '../constraint/line';
 import { push } from 'spica/array';
 
@@ -13,7 +13,7 @@ export function fence<C extends Context, D extends Parser<unknown, C>[]>(opener:
     const matches = opener.exec(source);
     if (!matches) return;
     assert(matches[0] === firstline(source, position));
-    consume(matches[0].length, context);
+    spend(context, matches[0].length);
     const delim = matches[1];
     assert(delim && delim === delim.trim());
     if (matches[0].includes(delim, delim.length)) return;

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

@@ -1,5 +1,5 @@
 import { Parser } from '../../data/parser';
-import { consume } from '../../../combinator';
+import { spend } from '../../../combinator';
 
 export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
 export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<N>): Parser<N> {
@@ -15,7 +15,7 @@ export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Pars
     const params = pattern.exec(source);
     if (!params) return;
     assert(source.startsWith(params[0], position));
-    count && consume(params[0].length, context);
+    count && spend(context, params[0].length);
     const result = f(params)(input);
     context.position += result
       ? context.position === position

package/src/combinator/data/delimiter.ts

@@ -1,5 +1,5 @@
 import { Parser, Input, List, Node, Context } from './parser';
-import { consume } from './parser/context';
+import { spend } from './parser/context';
 
 interface Delimiter {
   readonly memory: Delimiter[];
@@ -37,6 +37,8 @@ export class Delimiters {
         assert(pattern !== '');
         return index(`'${pattern}`);
       case 'object':
+        assert(pattern.flags.includes('y'));
+        assert(/^yu?$/.test(pattern.flags));
         return index(`/${pattern.source}`);
     }
   }
@@ -197,7 +199,7 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
         pos = position;
         if (index === -1) return;
         const src = source.slice(position, index);
-        count && !hit && consume(src.length, context);
+        count && !hit && spend(context, src.length);
         if (advance) {
           context.position = index;
         }
@@ -248,7 +250,7 @@ export function tester(pattern: string | RegExp, advance: boolean, after?: Parse
         pos = position;
         if (index === -1) return;
         const len = index - position;
-        count && !hit && consume(len, context);
+        count && !hit && spend(context, len);
         if (advance) {
           context.position = index;
         }

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

@@ -6,61 +6,35 @@ export function creation(cost: number, parser: Parser): Parser {
   assert(cost >= 0);
   return input => {
     const context = input;
-    const resources = context.resources ?? { clock: cost || 1, recursions: [1] };
-    const { recursions } = resources;
-    assert(recursions.length > 0);
     const result = parser(input);
     if (result === undefined) return;
-    consume(cost, context);
+    spend(context, cost);
     return result;
   };
 }
-export function consume(cost: number, context: Context): void {
-  const { resources } = context;
-  if (!resources) return;
+export function spend(context: Context, cost: number): void {
+  const resources = context.resources ?? { clock: cost || 1, recursions: [1] };
   if (resources.clock < cost) throw new Error('Too many creations');
   resources.clock -= cost;
 }
 
-export function recursion<P extends Parser>(recursion: number, parser: P): P;
-export function recursion(recursion: number, parser: Parser): Parser {
-  assert(recursion >= 0);
+export function recursion<P extends Parser>(index: number, parser: P): P;
+export function recursion(index: number, parser: Parser): Parser {
+  assert(index >= 0);
   return input => {
     const context = input;
     const resources = context.resources ?? { clock: 1, recursions: [1] };
     const { recursions } = resources;
-    assert(recursions.length > 0);
-    const rec = min(recursion, recursions.length - 1);
-    if (rec >= 0 && recursions[rec] < 1) throw new Error('Too much recursion');
-    rec >= 0 && --recursions[rec];
+    recur(recursions, index, 1);
     const result = parser(input);
-    rec >= 0 && ++recursions[rec];
+    recur(recursions, index, -1);
     return result;
   };
 }
-
-export function recursions<P extends Parser>(recursions: readonly number[], parser: P): P;
-export function recursions(rs: readonly number[], parser: Parser): Parser {
-  assert(rs.every(r => r >= 0));
-  return input => {
-    const context = input;
-    const resources = context.resources ?? { clock: 1, recursions: [4] };
-    const { recursions } = resources;
-    assert(recursions.length > 0);
-    for (const recursion of rs) {
-      const rec = min(recursion, recursions.length - 1);
-      if (rec === -1) continue;
-      if (recursions[rec] < 1) throw new Error('Too much recursion');
-      --recursions[rec];
-    }
-    const result = parser(input);
-    for (const recursion of rs) {
-      const rec = min(recursion, recursions.length - 1);
-      if (rec === -1) continue;
-      ++recursions[rec];
-    }
-    return result;
-  };
+export function recur(recursions: number[], index: number, size: number, force: boolean = false): void {
+  index = min(index, recursions.length && recursions.length - 1);
+  if (recursions[index] < size - +force) throw new Error('Too much recursion');
+  recursions[index] -= size;
 }
 
 export function precedence<P extends Parser>(precedence: number, parser: P): P;

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

@@ -4,24 +4,31 @@ import { Delimiters } from '../delimiter';
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
 export function some<P extends Parser>(parser: P, limit?: number): P;
-export function some<P extends Parser>(parser: P, delimiters?: readonly DelimiterOption[]): P;
-export function some<P extends Parser>(parser: P, delimiter: string | RegExp, delimiters?: readonly DelimiterOption[]): P;
-export function some<P extends Parser>(parser: P, delimiter: string | RegExp, after: string | RegExp, delimiters?: readonly DelimiterOption[]): P;
-export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp | readonly DelimiterOption[], after?: string | RegExp | readonly DelimiterOption[], delimiters?: readonly DelimiterOption[], limit = -1): Parser<N> {
+export function some<P extends Parser>(parser: P, delimiters?: readonly DelimiterOption[], limit?: number): P;
+export function some<P extends Parser>(parser: P, delimiter: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
+export function some<P extends Parser>(parser: P, delimiter: string | RegExp, after: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
+export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp | readonly DelimiterOption[], after?: number | string | RegExp | readonly DelimiterOption[], delimiters?: number | readonly DelimiterOption[], limit = 0): Parser<N> {
   if (typeof delimiter === 'number') {
     limit = delimiter;
+    delimiters = undefined;
     delimiter = undefined;
   }
   else if (Array.isArray(delimiter)) {
+    limit = after as number;
     delimiters = delimiter;
     delimiter = undefined;
   }
   else if (after === undefined || Array.isArray(after)) {
+    limit = delimiters as number;
     delimiters = after;
     after = undefined;
   }
+  else {
+    delimiters = delimiters as readonly DelimiterOption[];
+  }
   assert(parser);
   assert(delimiter !== '');
+  assert(delimiters === undefined || Array.isArray(delimiters));
   const match = Delimiters.tester(delimiter as string, after as string);
   const delims = delimiters?.map(([delimiter, precedence]) => ({
     signature: Delimiters.signature(delimiter),
@@ -31,7 +38,6 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
   return input => {
     const context = input;
     const { source, position } = context;
-    //assert(context.backtracks ??= {});
     let nodes: List<Node<N>> | undefined;
     delims && context.delimiters.push(delims);
     // whileは数倍遅い
@@ -43,7 +49,8 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
       if (result === undefined) break;
       if (context.position === pos) break;
       nodes = nodes?.import(result) ?? result;
-      if (limit >= 0 && context.position - position > limit) break;
+      // 次にパースに成功すれば確実に制限値を超えるので制限値ちょうどでも中止する
+      if (limit > 0 && context.position - position >= limit) break;
     }
     delims && context.delimiters.pop(delims.length);
     assert(context.position >= position);

package/src/parser/api/header.ts

@@ -8,7 +8,11 @@ export function header(source: string): string {
 
 export function headers(source: string): string[] {
   const [el] = parse(source);
-  return el?.textContent!.trimEnd().slice(el.firstChild!.firstChild!.textContent!.length).split(/\r?\n/) ?? [];
+  const acc = [];
+  for (let field = el?.firstChild?.firstChild; field = field?.nextSibling;) {
+    acc.push(field.textContent!);
+  }
+  return acc;
 }
 
 function parse(source: string): [HTMLElement, number] | [] {

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

@@ -125,7 +125,7 @@ describe('Unit: parser/api/parse', () => {
           '!{../../a}',
         ].join('\n\n'), { host: new URL(`${location.origin}/z`) }).children].map(el => el.outerHTML),
         [
-          '<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="url" data-value="https://source/x/y"><span class="field-name">URL</span>: <span class="field-value">https://source/x/y</span>\n</span></details></aside>',
+          '<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="url" data-value="https://source/x/y"><span class="field-name">URL</span>: <span class="field-value">https://source/x/y</span></div></details></aside>',
           '<p><a class="account" href="https://source/@a" target="_blank">@a</a></p>',
           '<p><a class="account" href="https://domain/@a" target="_blank">@domain/a</a></p>',
           '<p><a class="channel" href="https://source/@a?ch=b" target="_blank">@a#b</a></p>',
@@ -158,7 +158,7 @@ describe('Unit: parser/api/parse', () => {
           '{./a}',
         ].join('\n\n'), { host: new URL(`${location.origin}/index.md`) }).children].map(el => el.outerHTML),
         [
-          '<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="url" data-value="https://source/x/y"><span class="field-name">URL</span>: <span class="field-value">https://source/x/y</span>\n</span></details></aside>',
+          '<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="url" data-value="https://source/x/y"><span class="field-name">URL</span>: <span class="field-value">https://source/x/y</span></div></details></aside>',
           '<p><a class="url" href="/a">^/a</a></p>',
           '<p><a class="url" href="https://source/x/a" target="_blank">./a</a></p>',
         ]);
@@ -173,7 +173,7 @@ describe('Unit: parser/api/parse', () => {
           '{./a}',
         ].join('\n\n'), { host: new URL(`${location.origin}/z`) }).children].map(el => el.outerHTML),
         [
-          `<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="url" data-value="${location.origin}/x/y"><span class="field-name">URL</span>: <span class="field-value">${location.origin}/x/y</span>\n</span></details></aside>`,
+          `<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="url" data-value="${location.origin}/x/y"><span class="field-name">URL</span>: <span class="field-value">${location.origin}/x/y</span></div></details></aside>`,
           '<p><a class="url" href="/z/a">^/a</a></p>',
           '<p><a class="url" href="/x/a">./a</a></p>',
         ]);
@@ -204,9 +204,9 @@ describe('Unit: parser/api/parse', () => {
           '{#}',
         ].join('\n\n'), { host: new URL(`${location.origin}/z`) }).children].map(el => normalize(el.outerHTML)),
         [
-          `<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="url" data-value="https://example/x"><span class="field-name">URL</span>: <span class="field-value">https://example/x</span>\n</span></details></aside>`,
+          `<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="url" data-value="https://example/x"><span class="field-name">URL</span>: <span class="field-value">https://example/x</span></div></details></aside>`,
           '<pre class="invalid" translate="no">---\nURL: https://example/y\n---\n</pre>',
-          '<aside class="example" data-type="markdown"><pre translate="no">---\nURL: https://example/y\n---\n\n{#}</pre><hr><section><aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="url" data-value="https://example/y"><span class="field-name">URL</span>: <span class="field-value">https://example/y</span>\n</span></details></aside><p><a class="url" href="https://example/y#" target="_blank">#</a></p><h2>References</h2><ol class="references"></ol></section></aside>',
+          '<aside class="example" data-type="markdown"><pre translate="no">---\nURL: https://example/y\n---\n\n{#}</pre><hr><section><aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="url" data-value="https://example/y"><span class="field-name">URL</span>: <span class="field-value">https://example/y</span></div></details></aside><p><a class="url" href="https://example/y#" target="_blank">#</a></p><h2>References</h2><ol class="references"></ol></section></aside>',
           '<p><a class="url" href="https://example/x#" target="_blank">#</a></p>',
         ]);
     });
@@ -380,28 +380,28 @@ describe('Unit: parser/api/parse', () => {
       // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して1-4倍程度。
       // 5n = reference + link + url/math + ruby + text
       assert.deepStrictEqual(
-        [...parse(`((([[[[#$[${'.'.repeat(19998)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$http://[${'.'.repeat(19992)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['P']);
     });
 
     it('backtrack 1 error', () => {
       assert.deepStrictEqual(
-        [...parse(`((([[[[#$[${'.'.repeat(19998 + 1)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$http://[${'.'.repeat(19992 + 1)}`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['H1', 'PRE']);
     });
 
     it('backtrack 2', () => {
       assert.deepStrictEqual(
-        [...parse(`((([[[[#$[${'.'.repeat(19998)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$http://[${'.'.repeat(33324)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['P', 'OL']);
     });
 
     it('backtrack 2 error', () => {
       assert.deepStrictEqual(
-        [...parse(`((([[[[#$[${'.'.repeat(19998 + 1)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
+        [...parse(`((([[[[#$http://[${'.'.repeat(33324 + 1)}]]]`, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['H1', 'PRE']);
     });

package/src/parser/block/blockquote.ts

@@ -1,7 +1,7 @@
 import { BlockquoteParser } from '../block';
 import { Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, consume, recursion, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
+import { union, some, spend, recursion, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { unwrap, randomID } from '../util';
@@ -40,7 +40,7 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
     rewrite(
       some(contentline, opener),
       convert(unindent, context => {
-        consume(10, context);
+        spend(context, 10);
         const { source } = context;
         const references = html('ol', { class: 'references' });
         const document = parse(source, {

package/src/parser/block.ts

@@ -99,7 +99,7 @@ export const block: BlockParser = error(union([
       case '(':
         return olist(input);
       default:
-        if ('0' <= char && char <= '9') return olist(input);
+        if (char <= '9' && '0' <= char) return olist(input);
     }
   },
   paragraph

package/src/parser/context.ts

@@ -20,9 +20,9 @@ export class Context extends Ctx {
       id,
       caches,
     } = options;
-    this.resources ??= {
+    this.resources = options.resources ?? {
       // バックトラックのせいで文字数制限を受けないようにする。
-      clock: MAX_SEGMENT_SIZE * (6 + 1),
+      clock: MAX_SEGMENT_SIZE * (5 + 1),
       recursions: [
         5 || Recursion.block,
         20 || Recursion.blockquote,
@@ -42,7 +42,7 @@ export class Context extends Ctx {
     this.id = id;
     this.caches = caches;
   }
-  public override readonly resources?: {
+  public override readonly resources: {
     clock: number;
     recursions: number[];
   };
@@ -50,7 +50,7 @@ export class Context extends Ctx {
   public local: boolean;
   public sequential: boolean;
   public buffer: List<Node<(string | HTMLElement)>>;
-  public recursion = new RecursionCounter('annotation', 2);
+  public recursion = new RecursionCounter(2);
   public readonly header: boolean;
   public readonly host?: URL;
   public readonly url?: URL;
@@ -65,7 +65,6 @@ export type Options = Partial<Context>;
 
 class RecursionCounter {
   constructor(
-    private readonly syntax: string,
     private readonly limit: number,
   ) {
   }
@@ -75,7 +74,7 @@ class RecursionCounter {
     const { stack } = this
     for (; this.index > 0 && stack[this.index - 1] <= depth; --this.index);
     // 内側から数えるので無効化処理できずエラーを投げるしかない。
-    if (this.index === this.limit) throw new Error(`Too much ${this.syntax} recursion`);
+    if (this.index === this.limit) throw new Error(`Too much recursion`);
     stack[this.index] = depth;
     ++this.index;
   }

package/src/parser/header.test.ts

@@ -24,11 +24,11 @@ describe('Unit: parser/header', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\nC: D e\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\r\na: b\r\nC: D e\r\n---\r\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('----\na: b\n----', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\nC: D e\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\r\na: b\r\nC: D e\r\n---\r\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('----\na: b\n----', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
     });
 
   });

package/src/parser/header.ts

@@ -11,7 +11,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
     block(
       union([
         validate(context => context.header,
-        focus(/(---+)[^\S\r\n]*\r?\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\r\n]*\r?\n){1,100}\1[^\S\r\n]*(?:$|\r?\n)/yi,
+        focus(/(---+)[^\S\r\n]*\r?\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\r\n]*\r?\n){1,32}\1[^\S\r\n]*(?:$|\r?\n)/yi,
         convert(source =>
           source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n')),
           fmap(
@@ -42,11 +42,10 @@ const field: MarkdownParser.HeaderParser.FieldParser = line(({ source, position
   const name = source.slice(position, source.indexOf(':', position));
   const value = source.slice(position + name.length + 1).trim();
   return new List([
-    new Node(html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
+    new Node(html('div', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),
-      '\n',
     ])),
   ]);
 });

package/src/parser/inline/annotation.ts

@@ -25,7 +25,7 @@ import { html, defrag } from 'typed-dom/dom';
 // 常に非常に非効率な処理を行い常時低速化するより三重以上の注釈を禁止して効率性を維持するのが妥当である。
 const MAX_DEPTH = 20;
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation,
-  repeat('(', beforeNonblank, ')', [Recursion.bracket], precedence(1, surround(
+  repeat('(', beforeNonblank, ')', Recursion.bracket, precedence(1, surround(
     '',
     some(union([inline]), ')', [[')', 1]]),
     ')',
@@ -41,17 +41,22 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
           new Node(html('span', { class: bracketname(context, 1, 1) }, defrag(unwrap(nodes))))
         ]);
       }
-      recursion.add(MAX_DEPTH - (resources?.recursions[Recursion.bracket] ?? resources?.recursions.at(-1) ?? MAX_DEPTH));
+      recursion.add(
+        MAX_DEPTH - (resources?.recursions[Recursion.bracket] ?? resources?.recursions.at(-1) ?? MAX_DEPTH));
       context.position += 1;
       return new List([
-        new Node(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))]))
+        new Node(html('sup', { class: 'annotation' }, [
+          html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))
+        ]))
       ]);
     },
     (nodes, context, prefix, postfix) => {
       assert(postfix === 0);
       for (let i = 0; i < prefix; ++i) {
         nodes.unshift(new Node('('));
-        nodes = new List([new Node(html('span', { class: bracketname(context, 0, 0) }, defrag(unwrap(nodes))))]);
+        nodes = new List([
+          new Node(html('span', { class: bracketname(context, 0, 0) }, defrag(unwrap(nodes))))
+        ]);
         context.range += 1;
       }
       return nodes;

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

@@ -2,13 +2,12 @@ import { AutolinkParser } from '../../inline';
 import { State, Recursion, Backtrack } from '../../context';
 import { List, Node } from '../../../combinator/data/parser';
 import { union, tails, some, recursion, precedence, state, constraint, focus, rewrite, surround, open, lazy } from '../../../combinator';
-import { inline } from '../../inline';
 import { parse } from '../link';
 import { unescsource, str } from '../../source';
 
 export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
   open(
-    /(?<![0-9A-Za-z][.+-]?|[@#])https?:\/\/(?=[\x21-\x7E])/y,
+    /(?<![0-9A-Za-z][.+-]?|[@#])https?:\/\/(?=[[0-9A-Za-z])/y,
     precedence(0, some(union([
       some(unescsource, /(?<![-+*=~^_,.;:!?]|\/{3})(?:[-+*=~^_,.;:!?]|\/{3,}(?!\/))*(?=[\\$"`\[\](){}<>（）［］｛｝|]|[^\x21-\x7E]|$)/y),
       precedence(1, bracket),
@@ -18,7 +17,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
   union([
     constraint(State.autolink, state(State.autolink, context =>
       new List([new Node(parse(new List(), new List([new Node(context.source)]), context))]))),
-    open(str(/[^:]+/y), some(inline)),
+    context => new List([new Node(context.source)]),
   ])));
 
 export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
@@ -36,7 +35,7 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
             context))
         ]);
       })),
-      str(/[^:]+/y),
+      context => new List([new Node(context.source)]),
     ]),
   ])));
 

package/src/parser/inline/deletion.ts

@@ -9,7 +9,7 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() =>
-  repeat('~~', '', '~~', [Recursion.inline], precedence(0, surround(
+  repeat('~~', '', '~~', Recursion.inline, precedence(0, surround(
     '',
     some(union([
       some(inline, blankWith('\n', '~~')),

package/src/parser/inline/emstrong.ts

@@ -24,7 +24,7 @@ const subemphasis: Parser.IntermediateParser<EmphasisParser> = lazy(() => some(u
 // 可能な限り早く閉じるよう解析しなければならない。
 // このため終端記号の後ろを見て終端を中止し同じ構文を再帰的に適用してはならない。
 export const emstrong: EmStrongParser = lazy(() =>
-  repeat('***', beforeNonblank, '***', [Recursion.inline], precedence(0, surround(
+  repeat('***', beforeNonblank, '***', Recursion.inline, precedence(0, surround(
     '',
     some(union([some(inline, '*', afterNonblank)])),
     strs('*', 1, 3),

package/src/parser/inline/insertion.ts

@@ -9,7 +9,7 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() =>
-  repeat('++', '', '++', [Recursion.inline], precedence(0, surround(
+  repeat('++', '', '++', Recursion.inline, precedence(0, surround(
     '',
     some(union([
       some(inline, blankWith('\n', '++')),

package/src/parser/inline/italic.ts

@@ -12,7 +12,7 @@ import { html, defrag } from 'typed-dom/dom';
 // 斜体は単語に使うとかえって見づらく読み飛ばしやすくなるため使わないべきであり
 // ある程度の長さのある文に使うのが望ましい。
 export const italic: ItalicParser = lazy(() =>
-  repeat('///', beforeNonblank, '///', [Recursion.inline], precedence(0, surround(
+  repeat('///', beforeNonblank, '///', Recursion.inline, precedence(0, surround(
     '',
     some(union([inline]), '///', afterNonblank),
     '///',

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { LinkParser } from '../inline';
 import { Context, State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, sequence, subsequence, some, spend, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
@@ -109,7 +109,7 @@ export function parse(
   const INSECURE_URI = params.shift()!.value;
   assert(INSECURE_URI === INSECURE_URI.trim());
   assert(!INSECURE_URI.match(/\s/));
-  consume(10, context);
+  spend(context, 10);
   let uri: ReadonlyURL | undefined;
   try{
     uri = new ReadonlyURL(

package/src/parser/inline/mark.ts

@@ -10,7 +10,7 @@ import { unwrap } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() =>
-  repeat('==', beforeNonblank, '==', [Recursion.inline], precedence(0, surround(
+  repeat('==', beforeNonblank, '==', Recursion.inline, precedence(0, surround(
     '',
     state(State.mark, some(union([inline]), '==', afterNonblank)),
     '==',

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

@@ -93,8 +93,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser, input('$\\Begin$', new Context())), [['<span class="invalid" translate="no">$\\Begin$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('$\\begin{}$', new Context())), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser, input('${\\begin}$', new Context())), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('$http://host$', new Context())), [['<span class="invalid" translate="no">$http://host$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('${http://host}$', new Context())), [['<span class="invalid" translate="no">${http://host}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('$http://host$', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('${http://host}$', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input(' ${a}$', new Context())), undefined);
     });
 

package/src/parser/inline/math.ts

@@ -6,7 +6,7 @@ import { escsource, str } from '../source';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
-const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])|:\/\//i;
+const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
 export const math: MathParser = lazy(() => rewrite(
   union([
@@ -19,7 +19,7 @@ export const math: MathParser = lazy(() => rewrite(
     surround(
       /\$(?![\s{}])/y,
       precedence(2, some(union([
-        some(escsource, /\$|[`"{}\r\n]/y),
+        some(escsource, /[`"{}$\r\n]|(?<=[0-9A-Za-z]):\/\/[[0-9A-Za-z]/y),
         precedence(4, bracket),
       ]))),
       /(?<!\s)\$(?![-0-9A-Za-z])/y,
@@ -45,7 +45,7 @@ const bracket: MathParser.BracketParser = lazy(() => surround(
   recursion(Recursion.terminal,
   some(union([
     bracket,
-    some(escsource, /[{}$\r\n]/y),
+    some(escsource, /[{}$\r\n]|(?<=[0-9A-Za-z]):\/\/[[0-9A-Za-z]/y),
   ]))),
   str('}'),
   true));