securemark 0.291.1 → 0.293.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,11 @@ export interface MarkdownParser extends
   ]> {
 }
 export namespace MarkdownParser {
-  export interface Context extends Ctx {
+  export interface Context extends Ctx, Options {
+    buffer?: (string | HTMLElement)[];
+    sequential?: boolean;
+  }
+  export interface Options extends CtxOptions {
     readonly host?: URL;
     readonly url?: URL;
     readonly id?: string;
@@ -732,18 +735,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 +779,7 @@ export namespace MarkdownParser {
       // { uri }
       // [abc]{uri nofollow}
       Inline<'link'>,
-      Parser<HTMLAnchorElement, Context, [
+      Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
         LinkParser.MediaLinkParser,
         LinkParser.TextLinkParser,
       ]> {
@@ -798,7 +793,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 +802,7 @@ export namespace MarkdownParser {
       }
       export interface MediaLinkParser extends
         Inline<'link/medialink'>,
-        Parser<HTMLAnchorElement, Context, [
+        Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
           Parser<HTMLElement[], Context, [
             MediaParser,
             ShortMediaParser,
@@ -979,7 +974,7 @@ export namespace MarkdownParser {
       Inline<'insertion'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        InsertionParser,
+        InlineParser,
       ]> {
     }
     export interface DeletionParser extends
@@ -987,7 +982,7 @@ export namespace MarkdownParser {
       Inline<'deletion'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        DeletionParser,
+        InlineParser,
       ]> {
     }
     export interface MarkParser extends
@@ -995,7 +990,7 @@ export namespace MarkdownParser {
       Inline<'mark'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        MarkParser,
+        InlineParser,
       ]> {
     }
     export interface EmStrongParser extends
@@ -1010,11 +1005,9 @@ export namespace MarkdownParser {
       // **abc**
       Inline<'strong'>,
       Parser<HTMLElement | string, Context, [
+        EmphasisParser,
+        InlineParser,
         InlineParser,
-        Parser<HTMLElement | string, Context, [
-          EmStrongParser,
-          StrongParser,
-        ]>,
       ]> {
     }
     export interface EmphasisParser extends
@@ -1023,11 +1016,7 @@ export namespace MarkdownParser {
       Parser<HTMLElement | string, Context, [
         StrongParser,
         InlineParser,
-        Parser<HTMLElement | string, Context, [
-          EmStrongParser,
-          StrongParser,
-          EmphasisParser,
-        ]>,
+        InlineParser,
       ]> {
     }
     export interface ItalicParser extends
@@ -1035,7 +1024,7 @@ export namespace MarkdownParser {
       Inline<'italic'>,
       Parser<HTMLElement | string, Context, [
         InlineParser,
-        ItalicParser,
+        InlineParser,
       ]> {
     }
     export interface MathParser extends
@@ -1045,8 +1034,8 @@ export namespace MarkdownParser {
       Parser<HTMLElement, Context, [
         MathParser.BracketParser,
         Parser<string, Context, [
-          MathParser.BracketParser,
           SourceParser.EscapableSourceParser,
+          MathParser.BracketParser,
         ]>,
       ]> {
     }
@@ -1112,23 +1101,17 @@ export namespace MarkdownParser {
     export interface AutolinkParser extends
       Inline<'autolink'>,
       Parser<HTMLElement | string, Context, [
-        Parser<HTMLElement | string, Context, [
-          AutolinkParser.UrlParser.LineUrlParser,
-        ]>,
-        Parser<HTMLElement | string, Context, [
-          AutolinkParser.UrlParser,
-          AutolinkParser.EmailParser,
-          SourceParser.StrParser,
-          AutolinkParser.ChannelParser,
-          AutolinkParser.AccountParser,
-          SourceParser.StrParser,
-          SourceParser.StrParser,
-          AutolinkParser.HashtagParser,
-          AutolinkParser.HashnumParser,
-          SourceParser.StrParser,
-          SourceParser.StrParser,
-          AutolinkParser.AnchorParser,
-        ]>,
+        AutolinkParser.UrlParser.LineUrlParser,
+        AutolinkParser.UrlParser,
+        AutolinkParser.EmailParser,
+        SourceParser.StrParser,
+        AutolinkParser.ChannelParser,
+        AutolinkParser.AccountParser,
+        SourceParser.StrParser,
+        AutolinkParser.HashtagParser,
+        AutolinkParser.HashnumParser,
+        SourceParser.StrParser,
+        AutolinkParser.AnchorParser,
       ]> {
     }
     export namespace AutolinkParser {
@@ -1182,8 +1165,8 @@ export namespace MarkdownParser {
         // @user#tag
         Inline<'channel'>,
         Parser<string | HTMLAnchorElement, Context, [
-          InlineParser.AutolinkParser.AccountParser,
-          InlineParser.AutolinkParser.HashtagParser,
+          LinkParser.UnsafeLinkParser,
+          Parser<string, Context, []>,
         ]> {
       }
       export interface AccountParser extends

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.291.1",
+  "version": "0.293.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,36 +1,22 @@
-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';
+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;
 //export function contract<N>(patterns: string | RegExp | (string | RegExp)[], parser: Parser<N>, cond: (nodes: readonly N[], rest: string) => boolean): Parser<N> {
 //  return verify(validate(patterns, parser), cond);
 //}
 
-export function validate<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P): P;
+export function validate<P extends Parser<unknown>>(pattern: string | RegExp, parser: P): P;
 export function validate<P extends Parser<unknown>>(cond: ((input: Input<Context<P>>) => boolean), parser: P): P;
-export function validate<N>(patterns: string | RegExp | (string | RegExp)[] | ((input: Input<Ctx>) => boolean), parser: Parser<N>): Parser<N> {
-  if (typeof patterns === 'function') return guard(patterns, parser);
-  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 =>',
-    patterns.map(pattern =>
-      typeof pattern === 'string'
-        ? `|| source.slice(0, ${pattern.length}) === '${pattern}'`
-        : `|| /${pattern.source}/${pattern.flags}.test(source)`).join('').slice(2),
-  ].join(''));
+export function validate<N>(pattern: string | RegExp | ((input: Input<Ctx>) => boolean), parser: Parser<N>): Parser<N> {
+  if (typeof pattern === 'function') return guard(pattern, parser);
+  const match = matcher(pattern, false);
   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(input)) return;
+    return parser(input);
   };
 }
 
@@ -42,19 +28,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/clear.ts

@@ -1,7 +1,6 @@
-import { Parser, Ctx } from '../../data/parser';
-import { fmap } from '../monad/fmap';
+import { Parser, CtxOptions } from '../../data/parser';
 
 
-export function clear<D extends Parser<unknown, C>[], C extends Ctx>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
-  return fmap<never, Parser<unknown, C, D>>(parser, () => []);
+export function clear<D extends Parser<unknown, C>[], C extends CtxOptions>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
+  return input => parser(input) && [[]];
 }

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,42 @@
-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);
+  assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    opener.lastIndex = position;
+    const matches = opener.exec(source);
     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 +45,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, subinput, eval, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -13,27 +13,28 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
   if (typeof opener === 'function') {
     separation = parser as boolean;
     parser = opener;
-    opener = /^([ \t])\1*/;
+    opener = /([ \t])\1*/y;
   }
+  assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
   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) => {
       assert(parser = parser as Parser<N>);
-      // 影響する使用はないはず
-      //const { backtracks } = context;
-      //context.backtracks = {};
-      const result = parser({ source: trimBlockEnd(lines.join('')), context });
-      //context.backtracks = backtracks;
+      const result = parser(subinput(trimBlockEnd(lines.join('')), context));
       assert(result);
-      return result && exec(result) === ''
-        ? [eval(result), rest]
+      return result
+        ? [eval(result)]
         : undefined;
-    });
+    }));
 }
 
 function trimBlockEnd(block: string): string {