securemark 0.291.1 → 0.292.0

package/markdown.d.ts

@@ -1,5 +1,4 @@
-import { Parser, Ctx } from './src/combinator/data/parser';
-import { Command } from './src/parser/context';
+import { Parser, Ctx, CtxOptions } from './src/combinator/data/parser';
 import { Dict } from 'spica/dict';
 
 declare abstract class Markdown<T> {
@@ -13,7 +12,10 @@ export interface MarkdownParser extends
   ]> {
 }
 export namespace MarkdownParser {
-  export interface Context extends Ctx {
+  export interface Context extends Ctx, Options {
+    buffer?: (string | HTMLElement)[];
+  }
+  export interface Options extends CtxOptions {
     readonly host?: URL;
     readonly url?: URL;
     readonly id?: string;
@@ -732,18 +734,10 @@ export namespace MarkdownParser {
         export interface SignatureParser extends
           Inline<'extension/index/signature'>,
           Parser<string | HTMLElement, Context, [
-            InlineParser,
+            UnsafeHTMLEntityParser,
+            SourceParser.TxtParser,
           ]> {
         }
-        export namespace SignatureParser {
-          export interface InternalParser extends
-            Inline<'extension/index/signature/internal'>,
-            Parser<string, Context, [
-              UnsafeHTMLEntityParser,
-              SourceParser.TxtParser,
-            ]> {
-          }
-        }
       }
       export interface IndexerParser extends
         // [|signature]
@@ -784,7 +778,7 @@ export namespace MarkdownParser {
       // { uri }
       // [abc]{uri nofollow}
       Inline<'link'>,
-      Parser<HTMLAnchorElement, Context, [
+      Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
         LinkParser.MediaLinkParser,
         LinkParser.TextLinkParser,
       ]> {
@@ -798,7 +792,7 @@ export namespace MarkdownParser {
       }
       export interface TextLinkParser extends
         Inline<'link/textlink'>,
-        Parser<HTMLAnchorElement, Context, [
+        Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
           Parser<(HTMLElement | string)[], Context, [
             InlineParser,
           ]>,
@@ -807,7 +801,7 @@ export namespace MarkdownParser {
       }
       export interface MediaLinkParser extends
         Inline<'link/medialink'>,
-        Parser<HTMLAnchorElement, Context, [
+        Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
           Parser<HTMLElement[], Context, [
             MediaParser,
             ShortMediaParser,
@@ -1003,17 +997,23 @@ export namespace MarkdownParser {
       Inline<'emstrong'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InlineParser,
+        Parser<HTMLElement | string, Context, [
+          EmStrongParser,
+          StrongParser,
+          EmphasisParser,
+        ]>,
       ]> {
     }
     export interface StrongParser extends
       // **abc**
       Inline<'strong'>,
       Parser<HTMLElement | string, Context, [
+        EmphasisParser,
         InlineParser,
         Parser<HTMLElement | string, Context, [
           EmStrongParser,
           StrongParser,
+          EmphasisParser,
         ]>,
       ]> {
     }

package/package.json

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

package/src/combinator/control/constraint/block.test.ts

@@ -1,17 +1,20 @@
 import { block } from './block';
+import { input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/block', () => {
   describe('block', () => {
+    const { context: ctx } = input('', {});
+
     it('invalid', () => {
-      assert.throws(() => block(_ => [[], '\n'])({ source: ' \n', context: {} }));
+      assert.throws(() => block(_ => [[]])(input(' \n', ctx)));
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: '\n', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: ' \n', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], ''])({ source: '\n\n', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(block(_ => [[], '\n'])({ source: '\n\n', context: {} })), [[], '\n']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length - 1; return [[]]; })(input('\n\n', ctx)), ctx), [[], '\n']);
     });
 
   });

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

@@ -1,19 +1,19 @@
-import { Parser, exec } from '../../data/parser';
+import { Parser, failsafe } from '../../data/parser';
 import { firstline, isBlank } from './line';
 
 export function block<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
   assert(parser);
-  return input => {
-    const { source } = input;
-    if (source === '') return;
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
     const result = parser(input);
     if (result === undefined) return;
-    const rest = exec(result);
-    if (separation && !isBlank(firstline(rest))) return;
-    assert(rest === '' || source[source.length - rest.length - 1] === '\n');
-    return rest === '' || source[source.length - rest.length - 1] === '\n'
+    if (separation && !isBlank(firstline(source, context.position))) return;
+    assert(context.position === source.length || source[context.position - 1] === '\n');
+    return context.position === source.length || source[context.position - 1] === '\n'
       ? result
       : undefined;
-  };
+  });
 }

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

@@ -1,5 +1,5 @@
 import { isArray } from 'spica/alias';
-import { Parser, Input, Ctx, Node, Context, eval, exec, check } from '../../data/parser';
+import { Parser, Input, Ctx, Node, Context, eval, failsafe } from '../../data/parser';
 
 //export function contract<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
 //export function contract<N>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<N>, cond: (nodes: readonly N[], rest: string) => boolean): Parser<N> {
@@ -13,24 +13,19 @@ export function validate<N>(patterns: string | RegExp | (string | RegExp)[] | ((
   if (!isArray(patterns)) return validate([patterns], parser);
   assert(patterns.length > 0);
   assert(patterns.every(pattern => pattern instanceof RegExp ? !pattern.flags.match(/[gmy]/) && pattern.source.startsWith('^') : true));
-  const match: (source: string) => boolean = global.eval([
-    'source =>',
+  const match: (context: Ctx) => boolean = global.eval([
+    '({ source, position }) =>',
     patterns.map(pattern =>
       typeof pattern === 'string'
-        ? `|| source.slice(0, ${pattern.length}) === '${pattern}'`
-        : `|| /${pattern.source}/${pattern.flags}.test(source)`).join('').slice(2),
+        ? `|| source.startsWith('${pattern}', position)`
+        : `|| /${pattern.source}/${pattern.flags}.test(source.slice(position))`).join('').slice(2),
   ].join(''));
   return input => {
-    const { source } = input;
-    if (source === '') return;
-    if (!match(source)) return;
-    const result = parser(input);
-    assert(check(source, result));
-    if (result === undefined) return;
-    assert(exec(result).length < source.length);
-    return exec(result).length < source.length
-      ? result
-      : undefined;
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    if (!match(context)) return;
+    return parser(input);
   };
 }
 
@@ -42,19 +37,16 @@ function guard<N>(f: (input: Input<Ctx>) => boolean, parser: Parser<N>): Parser<
       : undefined;
 }
 
-export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: readonly Node<P>[], rest: string, context: Context<P>) => boolean): P;
-export function verify<N>(parser: Parser<N>, cond: (nodes: readonly N[], rest: string, context: Ctx) => boolean): Parser<N> {
+export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: readonly Node<P>[], context: Context<P>) => boolean): P;
+export function verify<N>(parser: Parser<N>, cond: (nodes: readonly N[], context: Ctx) => boolean): Parser<N> {
   assert(parser);
-  return input => {
-    const { source, context } = input;
-    if (source === '') return;
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
     const result = parser(input);
-    assert(check(source, result));
-    if (result === undefined) return;
-    if (!cond(eval(result), exec(result), context)) return;
-    assert(exec(result).length < source.length);
-    return exec(result).length < source.length
-      ? result
-      : undefined;
-  };
+    assert(context.position > position || !result);
+    if (result && !cond(eval(result), context)) return;
+    return result;
+  });
 }

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

@@ -1,18 +1,21 @@
+import { input } from '../../data/parser';
 import { line } from './line';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/line', () => {
   describe('line', () => {
+    const { context: ctx } = input('', {});
+
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '', context: {} })), undefined);
+      assert.deepStrictEqual(inspect(line(_ => [[]])(input('', ctx)), ctx), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: ' ', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '\n', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: '\n\n', context: {} })), [[], '\n']);
-      assert.deepStrictEqual(inspect(line(_ => [[], ''])({ source: ' \n', context: {} })), [[], '']);
-      assert.deepStrictEqual(inspect(line(_ => [[], '\n'])({ source: ' \n', context: {} })), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input(' ', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n\n', ctx)), ctx), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length - 1; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
     });
 
   });

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

@@ -1,33 +1,32 @@
-import { Parser, eval, exec, check } from '../../data/parser';
+import { Parser, input, eval, failsafe } from '../../data/parser';
 
 export function line<P extends Parser<unknown>>(parser: P): P;
 export function line<N>(parser: Parser<N>): Parser<N> {
   assert(parser);
-  return ({ source, context }) => {
-    if (source === '') return;
-    const line = firstline(source);
+  return failsafe(({ context }) => {
+    const { source, position } = context;
+    if (position === source.length) return;
+    const line = firstline(source, position);
     context.offset ??= 0;
-    context.offset += source.length - line.length;
-    const result = parser({ source: line, context });
-    assert(check(line, result));
-    context.offset -= source.length - line.length;
+    context.offset += position;
+    const result = parser(input(line, context));
+    context.position += position;
+    context.position += result && context.position === position ? line.length : 0;
+    assert(context.position > position || !result);
+    context.source = source;
+    context.offset -= position;
     if (result === undefined) return;
-    return isBlank(exec(result))
-      ? [eval(result), source.slice(line.length)]
-      : undefined;
-  };
+    if (!isBlank(source.slice(context.position, position + line.length))) return;
+    context.position = position + line.length;
+    return [eval(result)];
+  });
 }
 
-export function firstline(source: string): string {
-  const i = source.indexOf('\n');
-  switch (i) {
-    case -1:
-      return source;
-    case 0:
-      return '\n';
-    default:
-      return source.slice(0, i + 1);
-  }
+export function firstline(source: string, position: number): string {
+  const i = source.indexOf('\n', position);
+  return i === -1
+    ? source.slice(position)
+    : source.slice(position, i + 1);
 }
 
 export function isBlank(line: string): boolean {

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

@@ -1,18 +1,34 @@
-import { Parser, Ctx, Context, check } from '../../data/parser';
+import { Parser, Ctx, Context, subinput, failsafe } from '../../data/parser';
 
 export function convert<P extends Parser<unknown>>(conv: (source: string, context: Context<P>) => string, parser: P, continuous: boolean, empty?: boolean): P;
 export function convert<N>(conv: (source: string, context: Ctx) => string, parser: Parser<N>, continuous: boolean, empty = false): Parser<N> {
   assert(parser);
-  return ({ source, context }) => {
-    if (source === '') return;
-    const src = conv(source, context);
-    if (src === '') return empty ? [[], ''] : undefined;
-    const { backtracks } = context;
-    assert(source.endsWith(src) || src.endsWith(source) || !continuous);
-    context.backtracks = continuous ? backtracks : {};
-    const result = parser({ source: src, context });
-    assert(check(src, result));
-    context.backtracks = backtracks;
-    return result;
-  };
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    const src = conv(source.slice(position), context);
+    if (src === '') {
+      if (!empty) return;
+      context.position = source.length;
+      return [[]];
+    }
+    assert(source.endsWith(src) || src.endsWith(source, position) || !continuous);
+    if (continuous) {
+      context.position += source.length - position - src.length;
+      const result = parser(input);
+      assert(context.position > position || !result);
+      context.source = source;
+      return result;
+    }
+    else {
+    const { offset, backtracks } = context;
+      const result = parser(subinput(src, context));
+      context.position = context.source.length
+      assert(context.offset === offset);
+      assert(context.source === source);
+      assert(context.backtracks === backtracks);
+      return result;
+    }
+  });
 }

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

@@ -1,37 +1,40 @@
-import { Parser, Ctx } from '../../data/parser';
+import { Parser, Ctx, failsafe } from '../../data/parser';
 import { firstline, isBlank } from '../constraint/line';
 import { push } from 'spica/array';
 
 export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
-  return ({ source }) => {
-    if (source === '') return;
-    const matches = source.match(opener);
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    const matches = source.slice(position).match(opener);
     if (!matches) return;
-    assert(matches[0] === firstline(source));
+    assert(matches[0] === firstline(source, position));
     const delim = matches[1];
     assert(delim && delim === delim.trim());
     if (matches[0].includes(delim, delim.length)) return;
-    let rest = source.slice(matches[0].length);
+    context.position += matches[0].length;
     // Prevent annoying parsing in editing.
-    if (isBlank(firstline(rest)) && firstline(rest.slice(firstline(rest).length)).trimEnd() !== delim) return;
+    const secondline = firstline(source, context.position);
+    if (isBlank(secondline) && firstline(source, context.position + secondline.length).trimEnd() !== delim) return;
     let block = '';
     let closer = '';
     let overflow = '';
     for (let count = 1; ; ++count) {
-      if (rest === '') break;
-      const line = firstline(rest);
+      if (context.position === source.length) break;
+      const line = firstline(source, context.position);
       if ((closer || count > limit + 1) && isBlank(line)) break;
       if(closer) {
         overflow += line;
       }
       if (!closer && count <= limit + 1 && line.slice(0, delim.length) === delim && line.trimEnd() === delim) {
         closer = line;
-        if (isBlank(firstline(rest.slice(line.length)))) {
-          rest = rest.slice(line.length);
+        if (isBlank(firstline(source, context.position + line.length))) {
+          context.position += line.length;
           break;
         }
         if (!separation) {
-          rest = rest.slice(line.length);
+          context.position += line.length;
           break;
         }
         assert(!overflow);
@@ -40,8 +43,8 @@ export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: Reg
       if (!overflow) {
         block += line;
       }
-      rest = rest.slice(line.length);
+      context.position += line.length;
     }
-    return [push([block, overflow, closer], matches), rest];
-  };
+    return [push([block, overflow, closer], matches)];
+  });
 }

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

@@ -1,23 +1,26 @@
 import { indent } from './indent';
+import { input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/indent', () => {
   describe('indent', () => {
+    const { context: ctx } = input('', {});
+
     it('valid', () => {
-      const parser = indent(({ source }) => [[source], '']);
-      assert.deepStrictEqual(inspect(parser({ source: '', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: ' ', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: '  ', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: 'a ', context: {} })), undefined);
-      assert.deepStrictEqual(inspect(parser({ source: ' a\n', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a ', context: {} })), [['a '], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a \n', context: {} })), [['a '], '']);
-      assert.deepStrictEqual(inspect(parser({ source: '  a', context: {} })), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a\n a', context: {} })), [['a\na'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: ' a\n  a', context: {} })), [['a\n a'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: '  a\n a', context: {} })), [['a'], ' a']);
-      assert.deepStrictEqual(inspect(parser({ source: ' \ta', context: {} })), [['\ta'], '']);
-      assert.deepStrictEqual(inspect(parser({ source: '\ta', context: {} })), [['a'], '']);
+      const parser = indent(({ context }) => { context.position = context.source.length; return [[context.source]]; });
+      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input(' ', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('  ', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(input(' a\n', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a ', ctx)), ctx), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a \n', ctx)), ctx), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser(input('  a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a\n a', ctx)), ctx), [['a\na'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a\n  a', ctx)), ctx), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('  a\n a', ctx)), ctx), [['a'], ' a']);
+      assert.deepStrictEqual(inspect(parser(input(' \ta', ctx)), ctx), [['\ta'], '']);
+      assert.deepStrictEqual(inspect(parser(input('\ta', ctx)), ctx), [['a'], '']);
     });
 
   });

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

@@ -1,4 +1,4 @@
-import { Parser, eval, exec } from '../../data/parser';
+import { Parser, input, eval, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -16,24 +16,31 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
     opener = /^([ \t])\1*/;
   }
   assert(parser);
-  return bind(block(match(
+  return failsafe(bind(block(match(
     opener,
     memoize(
     ([indent]) =>
-      some(line(open(indent, ({ source }) => [[source], '']))),
+      some(line(open(indent, ({ context }) => {
+        const { source, position } = context;
+        context.position = source.length;
+        return [[source.slice(position)]];
+      }))),
     ([indent]) => indent.length * 2 + +(indent[0] === ' '), {})), separation),
-    (lines, rest, context) => {
+    (lines, context) => {
+      const { source, position } = context;
       assert(parser = parser as Parser<N>);
       // 影響する使用はないはず
       //const { backtracks } = context;
       //context.backtracks = {};
-      const result = parser({ source: trimBlockEnd(lines.join('')), context });
+      const result = parser(input(trimBlockEnd(lines.join('')), context));
       //context.backtracks = backtracks;
       assert(result);
-      return result && exec(result) === ''
-        ? [eval(result), rest]
+      context.position = position - (context.source.length - context.position);
+      context.source = source;
+      return result && context.position === position
+        ? [eval(result)]
         : undefined;
-    });
+    }));
 }
 
 function trimBlockEnd(block: string): string {

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

@@ -1,21 +1,22 @@
-import { Parser, exec, check } from '../../data/parser';
+import { Parser, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
 
 export function match<P extends Parser<unknown>>(pattern: RegExp, f: (matched: RegExpMatchArray) => P, cost?: boolean): P;
 export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<N>, cost = false): Parser<N> {
   assert(!pattern.flags.match(/[gmy]/) && pattern.source.startsWith('^'));
-  return input => {
-    const { source, context } = input;
-    if (source === '') return;
-    const param = source.match(pattern);
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    const param = source.slice(position).match(pattern);
     if (!param) return;
-    assert(source.startsWith(param[0]));
+    assert(source.startsWith(param[0], position));
     cost && consume(param[0].length, context);
     const result = f(param)(input);
-    assert(check(source, result, false));
-    if (result === undefined) return;
-    return exec(result).length < source.length && exec(result).length <= source.length
+    context.position += result && context.position === position ? param[0].length : 0;
+    assert(context.position > position || !result);
+    return context.position > position
       ? result
       : undefined;
-  };
+  });
 }

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

@@ -1,13 +1,17 @@
-import { Parser, Input, Result, Node, Context } from '../../data/parser';
+import { Parser, Input, Result, Ctx, Node, Context } from '../../data/parser';
 
 export function recover<P extends Parser<unknown>>(parser: P, fallback: (input: Input<Context<P>>, reason: unknown) => Result<Node<P>>): P;
-export function recover<N>(parser: Parser<N>, fallback: (input: Input, reason: unknown) => Result<N>): Parser<N> {
+export function recover<N>(parser: Parser<N>, fallback: (input: Input<Ctx>, reason: unknown) => Result<N>): Parser<N> {
   return input => {
+    const { context } = input;
+    const { source, position } = context;
     try {
       return parser(input);
     }
     catch (reason) {
       assert(reason instanceof Error && reason.name === 'AssertionError' && !+console.error(reason) && eval(`throw new Error("${reason.name}")`) || 1);
+      context.source = source;
+      context.position = position;
       return fallback(input, reason);
     }
   };