securemark 0.299.2 → 0.299.4

package/index.ts

@@ -1,5 +1,5 @@
 import 'spica/global';
 
-export * from './src/parser';
-export * from './src/util';
+export * from './src/api';
 export * from './src/renderer';
+export * from './src/util';

package/package.json

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

package/src/{parser/api → api}/bind.test.ts

@@ -1,8 +1,8 @@
-import { Progress } from '../../..';
+import { Progress } from '../..';
 import { bind } from './bind';
 import { frag, html } from 'typed-dom/dom';
 
-describe('Unit: parser/api/bind', () => {
+describe('Unit: api/bind', () => {
   describe('bind', () => {
     function inspect(iter: IterableIterator<Progress>, count = Infinity) {
       const acc: (string | undefined)[] = [];

package/src/{parser/api → api}/bind.ts

@@ -1,8 +1,8 @@
-import { ParserSettings, Progress } from '../../..';
-import { Context, Options, Segment } from '../context';
-import { input } from '../../combinator/data/parser';
-import { segment } from '../segment';
-import { block } from '../block';
+import { ParserSettings, Progress } from '../..';
+import { Context, Options, Segment } from '../parser/context';
+import { input } from '../combinator/data/parser';
+import { segment } from '../parser/segment';
+import { block } from '../parser/block';
 import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';

package/src/{parser/api → api}/body.test.ts

@@ -1,6 +1,6 @@
 import { body } from './body';
 
-describe('Unit: parser/api/body', () => {
+describe('Unit: api/body', () => {
   describe('body', () => {
     it('basic', () => {
       assert.deepStrictEqual(body(''), '');

package/src/{parser/api → api}/cache.ts

@@ -1,4 +1,4 @@
-import { Caches } from '../../..';
+import { Caches } from '../..';
 import { TClock } from 'spica/tclock';
 import { TLRU } from 'spica/tlru';
 

package/src/{parser/api → api}/header.test.ts

@@ -1,6 +1,6 @@
 import { headers } from './header';
 
-describe('Unit: parser/api/header', () => {
+describe('Unit: api/header', () => {
   describe('headers', () => {
     it('basic', () => {
       assert.deepStrictEqual(headers(''), []);

package/src/{parser/api → api}/header.ts

@@ -1,5 +1,5 @@
-import { Context } from '../context';
-import { header as h } from '../header';
+import { Context } from '../parser/context';
+import { header as h } from '../parser/header';
 
 export function header(source: string): string {
   const [, pos = 0] = parse(source);

package/src/{parser/api → api}/normalize.test.ts

@@ -1,6 +1,6 @@
 import { normalize, escape } from './normalize';
 
-describe('Unit: parser/normalize', () => {
+describe('Unit: normalize', () => {
   describe('normalize', () => {
     it('controls', () => {
       assert(normalize('\r') === '\n');

package/src/{parser/api → api}/parse.test.ts

@@ -1,9 +1,9 @@
 import { parse } from './parse';
-import { Context } from '../context';
+import { Context } from '../parser/context';
 import { html } from 'typed-dom/dom';
-import { normalize } from '../../debug.test';
+import { normalize } from '../debug.test';
 
-describe('Unit: parser/api/parse', () => {
+describe('Unit: api/parse', () => {
   describe('parse', () => {
     it('huge input', () => {
       assert.deepStrictEqual(

package/src/{parser/api → api}/parse.ts

@@ -1,8 +1,8 @@
-import { ParserOptions } from '../../..';
-import { input } from '../../combinator/data/parser';
-import { Context, Options, Segment } from '../context';
-import { segment } from '../segment';
-import { block } from '../block';
+import { ParserOptions } from '../..';
+import { input } from '../combinator/data/parser';
+import { Context, Options, Segment } from '../parser/context';
+import { segment } from '../parser/segment';
+import { block } from '../parser/block';
 import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';

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[];
@@ -199,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;
         }
@@ -250,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/{node.ts → list/list.ts}

@@ -1,4 +1,4 @@
-import { Parser, Context } from './parser';
+import { Parser, Context } from '../parser';
 
 export class List<N extends List.Node = List.Node, C extends Context = Context, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
@@ -134,8 +134,8 @@ export class List<N extends List.Node = List.Node, C extends Context = Context,
   }
 }
 export namespace List {
-  export class Node {
-    public next?: this = undefined;
-    public prev?: this = undefined;
+  export interface Node {
+    next?: this;
+    prev?: this;
   }
 }

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/inits.ts

@@ -1,7 +1,7 @@
 import { Parser, List, Node, Context } from '../parser';
 
-export function inits<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function inits<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
+export function inits<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, delimitation = false): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {
@@ -10,7 +10,7 @@ export function inits<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context,
     let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) break;
-      if (context.delimiters.test(input)) break;
+      if (delimitation && context.delimiters.test(input)) break;
       const result = parsers[i](input);
       if (result === undefined) break;
       nodes = nodes?.import(result) ?? result;

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

@@ -1,7 +1,7 @@
 import { Parser, List, Node, Context, failsafe } from '../parser';
 
-export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function sequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
+export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function sequence<N, D extends Parser<N>[]>(parsers: D, delimitation = false): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return failsafe(input => {
@@ -10,7 +10,7 @@ export function sequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Contex
     let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) return;
-      if (context.delimiters.test(input)) return;
+      if (delimitation && context.delimiters.test(input)) return;
       const result = parsers[i](input);
       if (result === undefined) return;
       nodes = nodes?.import(result) ?? result;

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

@@ -38,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は数倍遅い

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

@@ -2,12 +2,12 @@ import { Parser, Context } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function subsequence<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
+export function subsequence<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, delimitation = false): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>
       i + 1 < parsers.length
-        ? inits([parsers[i], subsequence(parsers.slice(i + 1))])
+        ? inits([parsers[i], subsequence(parsers.slice(i + 1), delimitation)], delimitation)
         : parsers[i]) as D);
 }

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

@@ -2,7 +2,7 @@ import { Parser, Context } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
-export function tails<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
-  return union(parsers.map((_, i) => sequence(parsers.slice(i))) as D);
+export function tails<P extends Parser>(parsers: Parser.SubParsers<P>, delimitation?: boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function tails<N, D extends Parser<N>[]>(parsers: D, delimitation?: boolean): Parser<N, Context, D> {
+  return union(parsers.map((_, i) => sequence(parsers.slice(i), delimitation)) as D);
 }

package/src/combinator/data/parser.ts

@@ -1,4 +1,4 @@
-import { List } from './node';
+import { List } from './list/list';
 import { Delimiters } from './delimiter';
 
 export type Parser<N = unknown, C extends Context = Context, D extends Parser<unknown, C>[] = any>

package/src/parser/block/blockquote.ts

@@ -1,11 +1,11 @@
 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';
-import { parse } from '../api/parse';
+import { parse } from '../../api/parse';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: BlockquoteParser.SegmentParser = block(union([
@@ -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/extension/aside.ts

@@ -4,7 +4,7 @@ import { List, Node } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { identity } from '../../inline/extension/indexee';
 import { unwrap, invalid, randomID } from '../../util';
-import { parse } from '../../api/parse';
+import { parse } from '../../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.block, fmap(

package/src/parser/block/extension/example.ts

@@ -4,7 +4,7 @@ import { List, Node, subinput } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { mathblock } from '../mathblock';
 import { unwrap, invalid, randomID } from '../../util';
-import { parse } from '../../api/parse';
+import { parse } from '../../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.block, fmap(

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,7 +20,7 @@ export class Context extends Ctx {
       id,
       caches,
     } = options;
-    this.resources ??= {
+    this.resources = options.resources ?? {
       // バックトラックのせいで文字数制限を受けないようにする。
       clock: MAX_SEGMENT_SIZE * (5 + 1),
       recursions: [
@@ -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/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]]),
     ')',

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';
@@ -35,7 +35,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
     // 自己再帰的にパースしてもオプションの不要なパースによる計算量の増加により相殺される。
     dup(surround(
       /{(?![{}])/y,
-      precedence(9, inits([uri, some(option)])),
+      inits([uri, some(option)]),
       / ?}/y,
       false, [],
       undefined,
@@ -83,7 +83,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
       ']')),
     dup(surround(
       /{(?![{}])/y,
-      precedence(9, inits([uri, some(option)])),
+      inits([uri, some(option)]),
       / ?}/y)),
   ]),
   ([{ value: content }, { value: params }], context) =>
@@ -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/media.ts

@@ -2,7 +2,7 @@ import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { Flag } from '../node';
-import { union, inits, tails, some, consume, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, spend, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { uri, option as linkoption, resolve, decode, parse } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
@@ -41,7 +41,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, open(
       })),
     dup(surround(
       /{(?![{}])/y,
-      precedence(9, inits([uri, some(option)])),
+      inits([uri, some(option)]),
       / ?}/y,
       false, [],
       undefined,
@@ -59,7 +59,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, open(
       text = text.trim();
       if (text === '' || text[0] !== tmp[0]) return;
     }
-    consume(100, context);
+    spend(context, 100);
     if (params.last!.value === Command.Cancel) {
       params.pop();
       return new List([

package/src/parser/inline.ts

@@ -135,5 +135,5 @@ export { shortmedia, lineshortmedia } from './inline/shortmedia';
 
 function isAlphabet(char: string): boolean {
   assert(char.length === 1);
-  return 'a' <= char && char <= 'z';
+  return char <= 'z' && 'a' <= char;
 }

package/src/parser/node.ts

@@ -1,4 +1,4 @@
-import { invisibleBlankHTMLEntityNames } from './api/normalize';
+import { invisibleBlankHTMLEntityNames } from '../api/normalize';
 
 export const enum Flag {
   none,