securemark 0.282.0 → 0.283.0

package/src/parser/inline/extension/placeholder.ts

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../../inline';
 import { union, some, syntax, creation, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { Syntax, State } from '../../context';
+import { State, Recursion } from '../../context';
 import { startTight } from '../../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -11,9 +11,9 @@ import { html, defrag } from 'typed-dom/dom';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(1, Recursion.inline, surround(
   str(/^\[[:^|]/),
-  syntax(Syntax.placeholder, 2, State.none,
+  syntax(2, State.none,
   startTight(some(union([inline]), ']', [[']', 2]]))),
   str(']'), false,
   ([, bs], rest) => [[
@@ -24,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest], 3))));

package/src/parser/inline/html.ts

@@ -2,7 +2,7 @@ import { HTMLParser } from '../inline';
 import { union, subsequence, some, syntax, creation, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { Clock } from 'spica/clock';
@@ -18,7 +18,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(syntax(Syntax.none, 4, State.none, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(1, Recursion.inline, syntax(4, State.none, union([
   focus(
     /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),

package/src/parser/inline/htmlentity.ts

@@ -1,9 +1,10 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, creation, validate, focus, fmap } from '../../combinator';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(validate('&', focus(
+export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(1, Recursion.ignore, validate('&', focus(
   /^&[0-9A-Za-z]+;/,
   ({ source }) => [[parse(source) ?? `\x1B${source}`], ''])));
 

package/src/parser/inline/insertion.ts

@@ -2,14 +2,14 @@ import { InsertionParser } from '../inline';
 import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => creation(surround(
+export const insertion: InsertionParser = lazy(() => creation(1, Recursion.inline, surround(
   str('++', '+'),
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   some(union([
     some(inline, blankWith('\n', '++')),
     open('\n', some(inline, '+'), true),

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

@@ -13,10 +13,10 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<a class="invalid">data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{any:alert}')), [['<a class="invalid">any:alert</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{"}')), [['<a class="url" href="&quot;">"</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{<}')), [['<a class="url" href="<">&lt;</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{<}')), [['<a class="url" href="&lt;">&lt;</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\}')), [['<a class="url" href="\\">\\</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{\\"}')), [['<a class="url" href="\\&quot;">\\"</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{\\<}')), [['<a class="url" href="\\<">\\&lt;</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{\\<}')), [['<a class="url" href="\\&lt;">\\&lt;</a>'], '']);
     });
 
     it('fishing', () => {

package/src/parser/inline/link.ts

@@ -4,7 +4,7 @@ import { union, inits, tails, sequence, some, constraint, syntax, creation, prec
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { linebreak, unescsource, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { trimBlankStart, trimNodeEnd } from '../visibility';
 import { stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
@@ -20,15 +20,15 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], union([
   textlink,
 ])));
 
-export const textlink: LinkParser.TextLinkParser = lazy(() => creation(10,
+export const textlink: LinkParser.TextLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link, false,
-  syntax(Syntax.link, 2, State.linkers | State.media,
+  syntax(2, State.linkers | State.media,
   bind(reverse(tails([
     dup(surround(
       '[',
       trimBlankStart(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
       ']',
-      true)),
+      true, undefined, undefined, 1)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
@@ -38,9 +38,9 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => creation(10,
     return [[parse(content, params, context)], rest];
   })))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(10,
+export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(1, Recursion.ignore,
   constraint(State.link | State.media, false,
-  syntax(Syntax.link, 2, State.linkers,
+  syntax(2, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
@@ -57,7 +57,7 @@ export const linemedialink: LinkParser.LineMediaLinkParser = surround(
   /^(?=[^\S\n]*(?:$|\n))/);
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
-  creation(10, precedence(2,
+  creation(1, Recursion.ignore, precedence(2,
   bind(reverse(tails([
     dup(surround(
       '[',

package/src/parser/inline/mark.ts

@@ -4,14 +4,14 @@ import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { unshift } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => creation(surround(
+export const mark: MarkParser = lazy(() => creation(1, Recursion.inline, surround(
   str('==', '='),
   constraint(State.mark, false,
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   startTight(some(union([
     some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
     open(some(inline, '=', [[/^\\?\n/, 9]]), mark),

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

@@ -115,8 +115,8 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$(0, 1]$)')), [['<span class="math" translate="no" data-src="$(0, 1]$">$(0, 1]$</span>'], ')']);
       assert.deepStrictEqual(inspect(parser('$\\{0,1\\}$')), [['<span class="math" translate="no" data-src="$\\{0,1\\}$">$\\{0,1\\}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$n=1$')), [['<span class="math" translate="no" data-src="$n=1$">$n=1$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$n<m$')), [['<span class="math" translate="no" data-src="$n<m$">$n&lt;m$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('$n>m$')), [['<span class="math" translate="no" data-src="$n>m$">$n&gt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$n<m$')), [['<span class="math" translate="no" data-src="$n&lt;m$">$n&lt;m$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$n>m$')), [['<span class="math" translate="no" data-src="$n&gt;m$">$n&gt;m$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$E = mc^2$')), [['<span class="math" translate="no" data-src="$E = mc^2$">$E = mc^2$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f(x)$')), [['<span class="math" translate="no" data-src="$f(x)$">$f(x)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$f: x \\to y$')), [['<span class="math" translate="no" data-src="$f: x \\to y$">$f: x \\to y$</span>'], '']);
@@ -143,7 +143,7 @@ describe('Unit: parser/inline/math', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('${*a*}$')), [['<span class="math" translate="no" data-src="${*a*}$">${*a*}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${<wbr>}$')), [['<span class="math" translate="no" data-src="${<wbr>}$">${&lt;wbr&gt;}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${<wbr>}$')), [['<span class="math" translate="no" data-src="${&lt;wbr&gt;}$">${&lt;wbr&gt;}$</span>'], '']);
     });
 
   });

package/src/parser/inline/math.ts

@@ -1,11 +1,12 @@
 import { MathParser } from '../inline';
 import { union, some, creation, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
-import { escsource, unescsource } from '../source';
+import { escsource, unescsource, str } from '../source';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => validate('$', creation(rewrite(
+export const math: MathParser = lazy(() => validate('$', creation(1, Recursion.ignore, rewrite(
   union([
     surround('$', precedence(6, bracket), '$'),
     surround(
@@ -31,11 +32,11 @@ export const math: MathParser = lazy(() => validate('$', creation(rewrite(
       source)
   ], '']))));
 
-const bracket: MathParser.BracketParser = lazy(() => creation(surround(
-  '{',
+const bracket: MathParser.BracketParser = lazy(() => creation(0, Recursion.terminal, surround(
+  str('{'),
   some(union([
     bracket,
     some(escsource, /^(?:[{}$]|\\?\n)/),
   ])),
-  '}',
+  str('}'),
   true)));

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

@@ -91,7 +91,7 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![\\[]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="["></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![\\"]{"?"#"}')), [['<a href="&quot;?&quot;#&quot;" target="_blank"><img class="media" data-src="&quot;?&quot;#&quot;" alt="&quot;"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![*a*]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="*a*"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![<wbr>]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="<wbr>"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![<wbr>]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="&lt;wbr&gt;"></a>'], '']);
     });
 
     it('external', () => {

package/src/parser/inline/media.ts

@@ -4,7 +4,7 @@ import { unsafelink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, linebreak, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { markInvalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
@@ -18,10 +18,10 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(10, open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(1, Recursion.ignore, open(
   '!',
   constraint(State.media, false,
-  syntax(Syntax.none, 2, ~State.link,
+  syntax(2, ~State.link,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
@@ -55,7 +55,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(10,
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
     if (context.state! & State.link) return [[el], rest];
-    if (cache && cache.tagName !== 'IMG') return creation(10, _ => [[el!], rest])({ source: '!', context });
+    if (cache && cache.tagName !== 'IMG') return [[el], rest];
     return fmap(
       unsafelink as MediaParser,
       ([link]) => [define(link, { class: null, target: '_blank' }, [el])])
@@ -67,7 +67,7 @@ export const linemedia: MediaParser.LineMediaParser = surround(
   union([media]),
   /^(?=[^\S\n]*(?:$|\n))/);
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,

package/src/parser/inline/reference.ts

@@ -2,24 +2,25 @@ import { ReferenceParser } from '../inline';
 import { union, subsequence, some, syntax, creation, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { blank, trimBlankStart, trimNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => creation(surround(
+export const reference: ReferenceParser = lazy(() => creation(1, Recursion.ignore, surround(
   '[[',
   constraint(State.reference, false,
-  syntax(Syntax.reference, 6, State.annotation | State.reference | State.media,
+  syntax(6, State.annotation | State.reference | State.media,
   subsequence([
     abbr,
     trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
   ]))),
   ']]',
   false,
-  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest])));
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  undefined, 1)));
 
 // Chicago-Style
-const abbr: ReferenceParser.AbbrParser = creation(surround(
+const abbr: ReferenceParser.AbbrParser = creation(1, Recursion.ignore, surround(
   '^',
   union([str(/^(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/)]),
   /^\|?(?=]])|^\|[^\S\n]*/,

package/src/parser/inline/remark.ts

@@ -2,12 +2,12 @@ import { RemarkParser } from '../inline';
 import { union, some, syntax, creation, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => validate('[%', creation(syntax(Syntax.none, 5, State.none, match(
+export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, syntax(5, State.none, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>

package/src/parser/inline/ruby.ts

@@ -3,12 +3,12 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, syntax, creation, validate, verify, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => validate('[', creation(syntax(Syntax.ruby, 2, State.all, fmap(verify(fmap(
+export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, syntax(2, State.all, fmap(verify(fmap(
   sequence([
     surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']'),
     surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')'),
@@ -51,7 +51,7 @@ export const ruby: RubyParser = lazy(() => validate('[', creation(syntax(Syntax.
     }
   })))));
 
-const text: RubyParser.TextParser = creation(1, false, ({ source, context }) => {
+const text: RubyParser.TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   const acc = [''];
   while (source !== '') {
     assert(source[0] !== '\n');

package/src/parser/inline/strong.ts

@@ -3,14 +3,14 @@ import { union, some, syntax, creation, surround, open, lazy } from '../../combi
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const strong: StrongParser = lazy(() => creation(surround(
+export const strong: StrongParser = lazy(() => creation(1, Recursion.inline, surround(
   str('**', '*'),
-  syntax(Syntax.none, 1, State.none,
+  syntax(1, State.none,
   startTight(some(union([
     some(inline, blankWith('**'), [[/^\\?\n/, 9]]),
     open(some(inline, '*', [[/^\\?\n/, 9]]), union([

package/src/parser/inline/template.ts

@@ -1,18 +1,18 @@
 import { TemplateParser } from '../inline';
 import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { Syntax, State } from '../context';
+import { State, Recursion } from '../context';
 import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
-export const template: TemplateParser = lazy(() => creation(surround(
+export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore, surround(
   '{{',
-  syntax(Syntax.none, 6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
+  syntax(6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
   '}}',
   true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest])));
 
-const bracket: TemplateParser.BracketParser = lazy(() => creation(union([
+const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true,
     undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true,

package/src/parser/inline.ts

@@ -70,6 +70,7 @@ export const inline: InlineParser = lazy(() => union([
 
 export { indexee } from './inline/extension/indexee';
 export { indexer } from './inline/extension/indexer';
+export { dataindex } from './inline/extension/index';
 export { medialink } from './inline/link';
 export { media } from './inline/media';
 export { shortmedia } from './inline/shortmedia';

package/src/parser/source/escapable.ts

@@ -1,10 +1,11 @@
 import { EscapableSourceParser } from '../source';
 import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
+import { Recursion } from '../context';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
-export const escsource: EscapableSourceParser = creation(1, false, ({ source, context }) => {
+export const escsource: EscapableSourceParser = creation(1, Recursion.ignore, ({ source, context }) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/str.ts

@@ -1,19 +1,20 @@
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';
+import { Recursion } from '../context';
 
 export function str(pattern: string | RegExp, not?: string): StrParser;
 export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creation(1, false, ({ source }) => {
+    ? creation(1, Recursion.ignore, ({ source }) => {
         if (source === '') return;
         if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creation(1, false, ({ source }) => {
+    : creation(1, Recursion.ignore, ({ source }) => {
         if (source === '') return;
         const m = source.match(pattern);
         if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;

package/src/parser/source/text.ts

@@ -1,6 +1,7 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { union, creation, focus } from '../../combinator';
 import { str } from './str';
+import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 export const delimiter = /[\s\x00-\x7F（）［］｛｝“”‘’「」『』]|\S[#>]/u;
@@ -8,7 +9,7 @@ export const nonWhitespace = /[\S\n]|$/u;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/u;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = creation(1, false, ({ source, context }) => {
+export const text: TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/unescapable.ts

@@ -1,8 +1,9 @@
 import { UnescapableSourceParser } from '../source';
 import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
+import { Recursion } from '../context';
 
-export const unescsource: UnescapableSourceParser = creation(1, false, ({ source, context }) => {
+export const unescsource: UnescapableSourceParser = creation(1, Recursion.ignore, ({ source, context }) => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);

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

@@ -1,57 +0,0 @@
-import { max } from 'spica/alias';
-
-export class Memo {
-  constructor(
-    public readonly targets = ~0,
-    public readonly margin = 0,
-  ) {
-  }
-  private memory: Record<number, Record<number, Record<number, readonly [unknown[], number] | readonly []>> | undefined> = {};
-  private count = 0;
-  private $length = 0;
-  public get length(): number {
-    return this.$length;
-  }
-  public get(
-    position: number,
-    syntax: number,
-    state: number,
-  ): readonly [unknown[], number] | readonly [] | undefined {
-    assert(position > 0);
-    if (this.count === 0) return;
-    //console.log('get', position, syntax, state, this.memory[position - 1]?.[syntax]?.[state]);
-    const cache = this.memory[position - 1]?.[syntax]?.[state];
-    return cache?.length === 2
-      ? [cache[0].slice(), cache[1]]
-      : cache;
-  }
-  public set(
-    position: number,
-    syntax: number,
-    state: number,
-    nodes: unknown[] | undefined,
-    offset: number,
-  ): void {
-    assert(position > 0);
-    this.$length = max(this.$length, position);
-    const record = this.memory[position - 1] ??= (++this.count, {});
-    assert(!record[syntax]?.[state]);
-    (record[syntax] ??= {})[state] = nodes
-      ? [nodes.slice(), offset]
-      : [];
-    //console.log('set', position, syntax, state, record[syntax]?.[state]);
-  }
-  public resize(position: number): void {
-    const memory = this.memory;
-    for (let i = this.$length; i > position; this.$length = --i) {
-      if (!(i in memory)) continue;
-      memory[i] &&= (--this.count, undefined);
-    }
-    //console.log('resize', position + 1);
-  }
-  public clear(): void {
-    this.memory = {};
-    this.count = 0;
-    this.$length = 0;
-  }
-}