securemark 0.294.0 → 0.294.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.294.0",
+  "version": "0.294.1",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -28,7 +28,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "spica": "0.0.807"
+    "spica": "0.0.809"
   },
   "devDependencies": {
     "@types/dompurify": "3.0.5",

package/src/combinator/control/constraint/contract.ts

@@ -1,4 +1,4 @@
-import { Parser, Input, List, Data, Ctx, Node, Context, eval, failsafe } from '../../data/parser';
+import { Parser, Input, List, Data, Ctx, Node, Context, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 //export function contract<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
@@ -37,7 +37,7 @@ export function verify<N>(parser: Parser<N>, cond: (nodes: List<Data<N>>, contex
     if (position === source.length) return;
     const result = parser(input);
     assert(context.position > position || !result);
-    if (result && !cond(eval(result), context)) return;
+    if (result && !cond(result, context)) return;
     return result;
   });
 }

package/src/combinator/control/constraint/line.ts

@@ -1,4 +1,4 @@
-import { Parser, input, eval, failsafe } from '../../data/parser';
+import { Parser, input, failsafe } from '../../data/parser';
 
 export function line<P extends Parser<unknown>>(parser: P): P;
 export function line<N>(parser: Parser<N>): Parser<N> {
@@ -18,7 +18,7 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     if (result === undefined) return;
     if (!isBlank(source.slice(context.position, position + line.length))) return;
     context.position = position + line.length;
-    return eval(result);
+    return result;
   });
 }
 

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, subinput, eval, failsafe } from '../../data/parser';
+import { Parser, List, Data, subinput, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -26,14 +26,10 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
         context.position = source.length;
         return new List([new Data(source.slice(position))]);
       }))),
-    ([indent]) => indent.length * 2 + +(indent[0] === ' '), {})), separation),
+    ([indent]) => indent.length <= 16 ? indent.length * 2 + +(indent[0] === ' ') : -1, [])), separation),
     (lines, context) => {
       assert(parser = parser as Parser<N>);
-      const result = parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
-      assert(result);
-      return result
-        ? eval(result)
-        : undefined;
+      return parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
     }));
 }
 

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

@@ -1,4 +1,4 @@
-import { Parser, Context, input, eval, failsafe } from '../../data/parser';
+import { Parser, Context, input, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P): P;
@@ -8,7 +8,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
   return failsafe(({ context }) => {
     const { source, position } = context;
     if (position === source.length) return;
-    const src = eval(match({ context }))?.head?.value ?? '';
+    const src = match({ context })?.head?.value ?? '';
     assert(source.startsWith(src, position));
     if (src === '') return;
     context.range = src.length;
@@ -20,8 +20,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
     assert(context.position > position || !result);
     context.source = source;
     context.offset -= position;
-    if (result === undefined) return;
-    return eval(result);
+    return result;
   });
 }
 
@@ -47,7 +46,6 @@ export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>): Parser<N>
     assert(context.position > position || !res2);
     context.source = source;
     context.offset -= position;
-    if (res2 === undefined) return;
-    return eval(res2);
+    return res2;
   });
 }

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

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
 import { matcher, clear } from '../../../combinator';
 
 export function surround<P extends Parser<unknown>, S = string>(
@@ -52,29 +52,26 @@ export function surround<N>(
     if (position === source.length) return;
     const { linebreak } = context;
     context.linebreak = 0;
-    const resultO = opener(input);
+    const nodesO = opener(input);
     assert(context.position >= position);
-    const nodesO = eval(resultO);
     if (!nodesO) {
       return void revert(context, linebreak);
     }
     if (isBacktrack(context, backtracks, position, context.position - position || 1)) {
       return void revert(context, linebreak);
     }
-    const resultM = context.position < source.length ? parser(input) : undefined;
+    const nodesM = context.position < source.length ? parser(input) : undefined;
     assert(context.position >= position);
     context.range = context.position - position;
-    const nodesM = eval(resultM);
-    if (!resultM && !optional) {
+    if (!nodesM && !optional) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);
       revert(context, linebreak);
       return result;
     }
-    const resultC = resultM || optional ? closer(input) : undefined;
+    const nodesC = nodesM || optional ? closer(input) : undefined;
     assert(context.position >= position);
     context.range = context.position - position;
-    const nodesC = eval(resultC);
     if (!nodesC) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);

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

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, failsafe } from '../../data/parser';
 
 export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: List<Data<SubNode<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
 export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
@@ -14,9 +14,8 @@ export function bind<N, U>(parser: Parser<N>, f: (nodes: List<Data<N>>, context:
     assert(context.position > position || !res1);
     if (res1 === undefined) return;
     context.range = context.position - position;
-    const res2 = f(eval(res1), context);
+    const res2 = f(res1, context);
     assert(context.position > position || !res2);
-    if (res2 === undefined) return;
     return context.position > position
       ? res2
       : undefined;

package/src/combinator/data/data.ts

@@ -1,6 +1,6 @@
-// Memory-efficient flexible list.
+import { CtxOptions, Parser } from './parser';
 
-export class List<N extends List.Node = List.Node> {
+export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, CtxOptions, input, eval } from '../parser';
+import { Parser, List, Data, Ctx, CtxOptions, input } from '../parser';
 import { some } from './some';
 import { reset, context, creation } from './context';
 import { unwrap } from '../../../parser/util';
@@ -18,7 +18,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('root', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = {};
-      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('123', ctx)))!)], [3, 2, 1]);
+      assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
       assert.throws(() => reset(base, parser)(input('1234', ctx)));
@@ -28,7 +28,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('node', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = { resources: { clock: 2, recursions: [1] } };
-      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('1', ctx)))!)], [2]);
+      assert.deepStrictEqual([...unwrap(reset(base, parser)(input('1', ctx))!)], [2]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 1);
       assert.throws(() => reset(base, parser)(input('12', ctx)));
@@ -47,7 +47,7 @@ describe('Unit: combinator/data/parser/context', () => {
     it('', () => {
       const base: Context = { status: true };
       const ctx: Context = { resources: { clock: 2, recursions: [1] } };
-      assert.deepStrictEqual([...unwrap(eval(context(base, parser)(input('1', ctx)))!)], [true]);
+      assert.deepStrictEqual([...unwrap(context(base, parser)(input('1', ctx))!)], [true]);
       assert(base.resources?.clock === undefined);
       assert(ctx.resources?.clock === 1);
       assert(ctx.status === undefined);

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, eval, Ctx } from '../parser';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, Ctx } from '../parser';
 
 export function inits<P extends Parser<unknown, Ctx>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
 export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
@@ -13,13 +13,11 @@ export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: Lis
       if (context.delimiters?.match(input)) break;
       const result = parsers[i](input);
       if (result === undefined) break;
-      nodes = nodes
-        ? nodes.import(eval(result))
-        : eval(result);
-      if (resume?.(eval(result)) === false) break;
+      nodes = nodes?.import(result) ?? result;
+      if (resume?.(result) === false) break;
     }
     assert(context.position >= position);
-    return nodes && context.position > position
+    return context.position > position
       ? nodes
       : undefined;
   };

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, eval } from '../parser';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
 
 export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
 export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
@@ -13,13 +13,11 @@ export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes:
       if (context.delimiters?.match(input)) return;
       const result = parsers[i](input);
       if (result === undefined) return;
-      nodes = nodes
-        ? nodes.import(eval(result))
-        : eval(result);
-      if (resume?.(eval(result)) === false) return;
+      nodes = nodes?.import(result) ?? result;
+      if (resume?.(result) === false) return;
     }
     assert(context.position >= position);
-    return nodes && context.position > position
+    return context.position > position
       ? nodes
       : undefined;
   };

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, eval } from '../parser';
+import { Parser, List, Data } from '../parser';
 import { Delimiters } from './context/delimiter';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
@@ -23,22 +23,20 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);
     }
-    while (true) {
-      if (context.position === source.length) break;
+    // whileは数倍遅い
+    for (; context.position < source.length;) {
       if (match(input)) break;
       if (context.delimiters?.match(input)) break;
       const result = parser(input);
       if (result === undefined) break;
-      nodes = nodes
-        ? nodes.import(eval(result))
-        : eval(result);
+      nodes = nodes?.import(result) ?? result;
       if (limit >= 0 && context.position - position > limit) break;
     }
     if (delims.length > 0) {
       context.delimiters!.pop(delims.length);
     }
     assert(context.position >= position);
-    return nodes && context.position > position
+    return context.position > position
       ? nodes
       : undefined;
   };

package/src/combinator/data/parser.ts

@@ -7,8 +7,7 @@ export interface Input<C extends CtxOptions = CtxOptions> {
   readonly context: C & Ctx;
 }
 export type Result<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
-  = readonly [never, C, D]
-  | List<Data<N>>
+  = List<Data<N>, C, D>
   | undefined;
 export { List };
 export class Data<N> implements List.Node {
@@ -78,28 +77,11 @@ export function clean<C extends Ctx>(context: C): C {
   return context;
 }
 
-export { eval_ as eval };
-function eval_<N>(result: NonNullable<Result<N>>, default_?: List<Data<N>>): List<Data<N>>;
-function eval_<N>(result: Result<N>, default_: List<Data<N>>): List<Data<N>>;
-function eval_<N>(result: Result<N>, default_?: undefined): List<Data<N>> | undefined;
-function eval_<N>(result: Result<N>, default_?: List<Data<N>>): List<Data<N>> | undefined {
-  assert(!Array.isArray(result));
-  return result
-    ? result as List<Data<N>>
-    : default_;
-}
-
 export function failsafe<P extends Parser<unknown>>(parser: P): P;
 export function failsafe<N>(parser: Parser<N>): Parser<N> {
   assert(parser);
   return input => {
-    const { context } = input;
-    const { source, position } = context;
-    const result = parser(input);
-    if (result === undefined) {
-      context.source = source;
-      context.position = position;
-    }
-    return result;
+    const position = input.context.position;
+    return parser(input) ?? (input.context.position = position, undefined);
   };
 }

package/src/debug.test.ts

@@ -1,10 +1,10 @@
-import { Result, Ctx, eval } from './combinator/data/parser';
+import { Result, Ctx } from './combinator/data/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
 export function inspect(result: Result<DocumentFragment | HTMLElement | string>, ctx: Ctx, until: number | string = Infinity): [string[], string] | undefined {
   return result && [
-    eval(result).foldl<string[]>((acc, { value: node }) => {
+    result.foldl<string[]>((acc, { value: node }) => {
       assert(node);
       if (typeof node === 'string') return acc.push(node), acc;
       if (node instanceof DocumentFragment) return acc.push(html('div', [node]).innerHTML), acc;

package/src/parser/api/bind.ts

@@ -1,6 +1,6 @@
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
-import { input, eval } from '../../combinator/data/parser';
+import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
@@ -75,7 +75,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header(input(seg, { header: index === 0 } as MarkdownParser.Options)) || block(input(seg, context)))
+      const es = (header(input(seg, { header: index === 0 } as MarkdownParser.Options)) || block(input(seg, context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
@@ -83,7 +83,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.
       push(adds, es.map(el => [el, base] as const));
       adds.reverse();
-      while (adds.length > 0) {
+      for (; adds.length > 0;) {
         assert(rev === revision);
         const [el, base] = adds.pop()!;
         target.insertBefore(el, base);
@@ -100,7 +100,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     }
     assert(blocks.length === sourceSegments.length);
     adds.reverse();
-    while (adds.length > 0) {
+    for (; adds.length > 0;) {
       assert(rev === revision);
       const [el, base] = adds.pop()!;
       target.insertBefore(el, base);
@@ -109,7 +109,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       if (rev !== revision) return yield { type: 'cancel' };
     }
     dels.reverse();
-    while (dels.length > 0) {
+    for (; dels.length > 0;) {
       assert(rev === revision);
       const [el] = dels.pop()!;
       el.parentNode?.removeChild(el);

package/src/parser/api/header.ts

@@ -1,4 +1,4 @@
-import { input, eval } from '../../combinator/data/parser';
+import { input } from '../../combinator/data/parser';
 import { header as h } from '../header';
 
 export function header(source: string): string {
@@ -14,7 +14,7 @@ export function headers(source: string): string[] {
 function parse(source: string): [HTMLElement, number] | [] {
   const i = input(source, {});
   const result = h(i);
-  const el = eval(result)?.head?.value;
+  const el = result?.head?.value;
   return el?.tagName === 'ASIDE'
     ? [el, i.context.position]
     : [];

package/src/parser/api/normalize.ts

@@ -1,4 +1,4 @@
-import { input, eval } from '../../combinator/data/parser';
+import { input } from '../../combinator/data/parser';
 import { unsafehtmlentity } from '../inline/htmlentity';
 
 const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
@@ -60,7 +60,7 @@ export const invisibleHTMLEntityNames = [
 ] as const;
 const unreadableHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames.slice(2);
 const unreadableEscapableCharacters = unreadableHTMLEntityNames
-  .map(name => eval(unsafehtmlentity(input(`&${name};`, {})))!.head!.value);
+  .map(name => unsafehtmlentity(input(`&${name};`, {}))!.head!.value);
 assert(unreadableEscapableCharacters.length === unreadableHTMLEntityNames.length);
 assert(unreadableEscapableCharacters.every(c => c.length === 1));
 const unreadableEscapableCharacter = new RegExp(`[${unreadableEscapableCharacters.join('')}]`, 'g');

package/src/parser/api/parse.ts

@@ -1,6 +1,6 @@
 import { ParserOptions } from '../../..';
 import { MarkdownParser } from '../../../markdown';
-import { input, eval } from '../../combinator/data/parser';
+import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
@@ -35,7 +35,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   let index = 0;
   for (const seg of segment(source)) {
     node.append(
-      ...eval(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)))
+      ...(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
   }
   assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));

package/src/parser/block/codeblock.ts

@@ -1,5 +1,5 @@
 import { CodeBlockParser } from '../block';
-import { List, Data, subinput, eval } from '../../combinator/data/parser';
+import { List, Data, subinput } from '../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { unwrap, invalid } from '../util';
@@ -73,6 +73,6 @@ export const codeblock: CodeBlockParser = block(fmap(
       params.lang
         ? context.caches?.code?.get(`${params.lang ?? ''}\n${body.slice(0, -1)}`)?.cloneNode(true).childNodes ||
           body.slice(0, -1) || undefined
-        : defrag(unwrap(eval(autolink(subinput(body.slice(0, -1), context)), new List()))));
+        : defrag(unwrap(autolink(subinput(body.slice(0, -1), context)))));
     return new List([new Data(el)]);
   }));

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

@@ -1,6 +1,6 @@
 import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
-import { List, Data, subinput, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { mathblock } from '../mathblock';
 import { unwrap, invalid } from '../../util';
@@ -49,7 +49,7 @@ export const example: ExtensionParser.ExampleParser = recursion(Recursion.block,
           new Data(html('aside', { class: 'example', 'data-type': 'math' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
-            eval(mathblock(subinput(`$$\n${body}$$`, context)))!.head!.value,
+            mathblock(subinput(`$$\n${body}$$`, context))!.head!.value,
           ])),
         ]);
       default:

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

@@ -44,7 +44,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length, {})));
+  ([, fence]) => fence.length <= 16 ? fence.length : -1, [])));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { List, Data, subinput, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { union, block, fence, fmap } from '../../../combinator';
 import { segment } from '../../segment';
 import { emptyline } from '../../source';
@@ -58,7 +58,7 @@ export const message: MessageParser = block(fmap(
         },
         [...segment(body)].reduce(
           (acc, seg) =>
-            push(acc, unwrap(eval(content(subinput(seg, context)))!)),
+            push(acc, unwrap(content(subinput(seg, context)))),
           [html('h1', title(type))])))
     ]);
   }));

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

@@ -1,6 +1,6 @@
 import { max, min } from 'spica/alias';
 import { ExtensionParser } from '../../block';
-import { List, Data, subinput, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
 import { inline, medialink, media, lineshortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
@@ -42,7 +42,7 @@ export const table: TableParser = block(fmap(
     switch (type) {
       case 'grid':
       case undefined:
-        return (eval(parser(subinput(body, context))) ?? new List([new Data(html('table'))]))
+        return (parser(subinput(body, context)) ?? new List([new Data(html('table'))]))
           .foldl(
             (acc, { value }) => acc.push(new Data(define(value, { 'data-type': type }))) && acc,
             new List());

package/src/parser/block.ts

@@ -61,6 +61,10 @@ export const block: BlockParser = reset(
       if (position === source.length) return;
       const fst = source[position];
       switch (fst) {
+        case '\n':
+          assert(source.trim() === '');
+          input.context.position = source.length;
+          return new List();
         case '=':
           if (source.startsWith('===', position)) return pagebreak(input);
           break;

package/src/parser/inline/emstrong.ts

@@ -1,6 +1,6 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { Result, List, Data, Node, Context, IntermediateParser, eval } from '../../combinator/data/parser';
+import { Result, List, Data, Node, Context, IntermediateParser } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
@@ -105,7 +105,7 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
           case 0:
             break;
           case 1:
-            nodes = eval(bind<EmphasisParser>(
+            nodes = bind<EmphasisParser>(
               subemphasis,
               ds => {
                 const { source } = context;
@@ -117,11 +117,11 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
                   return prepend('*', nodes.import(ds));
                 }
               })
-              ({ context })) ?? prepend('*', nodes);
+              ({ context }) ?? prepend('*', nodes);
             prefix -= 1;
             break;
           case 2:
-            nodes = eval(bind<StrongParser>(
+            nodes = bind<StrongParser>(
               substrong,
               ds => {
                 const { source } = context;
@@ -133,7 +133,7 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
                   return prepend('**', nodes.import(ds));
                 }
               })
-              ({ context })) ?? prepend('**', nodes);
+              ({ context }) ?? prepend('**', nodes);
             prefix -= 2;
             break;
         }

package/src/parser/inline/reference.ts

@@ -1,6 +1,6 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
-import { List, Data, eval } from '../../combinator/data/parser';
+import { List, Data } from '../../combinator/data/parser';
 import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
@@ -78,7 +78,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
           })
           ({ context });
         if (state & State.annotation && next) {
-          return (as as List<Data<string | HTMLElement>>).import(bs).import(eval(result!)).import(eval(next));
+          return (as as List<Data<string | HTMLElement>>).import(bs).import(result).import(next);
         }
       }
       context.position = position;

package/src/parser/inline/ruby.ts

@@ -1,6 +1,6 @@
 import { RubyParser } from '../inline';
 import { Backtrack } from '../context';
-import { List, Data, eval } from '../../combinator/data/parser';
+import { List, Data } from '../../combinator/data/parser';
 import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { txt } from '../source';
@@ -76,7 +76,7 @@ const text: RubyParser.TextParser = input => {
       case '&': {
         const result = unsafehtmlentity(input) ?? txt(input)!;
         assert(result);
-        acc.last!.value += eval(result).head!.value;
+        acc.last!.value += result.head!.value;
         continue;
       }
       default: {
@@ -88,7 +88,7 @@ const text: RubyParser.TextParser = input => {
         }
         const result = txt(input)!;
         assert(result);
-        acc.last!.value += eval(result).head?.value ?? '';
+        acc.last!.value += result.head?.value ?? '';
         continue;
       }
     }
@@ -103,7 +103,7 @@ const text: RubyParser.TextParser = input => {
 function* zip<N extends List.Node>(a: List<N>, b: List<N>): Iterable<[N | undefined, N | undefined]> {
   const ia = a[Symbol.iterator]();
   const ib = b[Symbol.iterator]();
-  while (true) {
+  for (; ;) {
     const ra = ia.next();
     const rb = ib.next();
     if (ra.done) break;

package/src/parser/processor/note.ts

@@ -191,7 +191,7 @@ function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Genera
   for (const [key, def] of defs) {
     defs.delete(key);
     ++count;
-    while (length > size) {
+    for (; length > size;) {
       const node = children[count - 1] as HTMLLIElement;
       if (equal(node, def)) continue I;
       yield note.removeChild(node);
@@ -207,7 +207,7 @@ function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Genera
     ++length;
     assert(children.length === length);
   }
-  while (length > size) {
+  for (; length > size;) {
     yield note.removeChild(children[size] as HTMLLIElement);
     --length;
     assert(children.length === length);