securemark 0.288.0 → 0.288.2

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

@@ -7,10 +7,10 @@ describe('Unit: parser/inline/media', () => {
     const parser = (source: string) => some(media)({ source, context: {} });
 
     it('xss', () => {
-      assert.deepStrictEqual(inspect(parser('![]{javascript:alert}')), [['<img class="media invalid" data-src="javascript:alert" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{vbscript:alert}')), [['<img class="media invalid" data-src="vbscript:alert" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<img class="media invalid" data-src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{any:alert}')), [['<img class="media invalid" data-src="any:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{javascript:alert}')), [['<img class="invalid" data-src="javascript:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{vbscript:alert}')), [['<img class="invalid" data-src="vbscript:alert" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K}')), [['<img class="invalid" data-src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{any:alert}')), [['<img class="invalid" data-src="any:alert" alt="">'], '']);
       assert.deepStrictEqual(inspect(parser('![]{"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![\\"]{/}')), [['<a href="/" target="_blank"><img class="media" data-src="/" alt="&quot;"></a>'], '']);
@@ -30,6 +30,8 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{   }')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{/}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{}}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{{}}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{b}}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{b\nc}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{a\\\nc}')), undefined);
@@ -42,20 +44,20 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![\\ ]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![\\\n]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![&Tab;]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![&a;]{b}')), [['<img class="media invalid" data-src="b" alt="&amp;a;">'], '']);
+      assert.deepStrictEqual(inspect(parser('![&a;]{b}')), [['<img class="invalid" data-src="b" alt="&amp;a;">'], '']);
       assert.deepStrictEqual(inspect(parser('![[]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\nb]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![a\\\nb]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="media invalid" data-src="ttp://host" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{tel:1234567890}')), [['<img class="media invalid" data-src="tel:1234567890" alt="">'], '']);
-      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0%1]}')), [['<img class="media invalid" alt="">'], '']);
-      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0/96]}')), [['<img class="media invalid" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{.}')), [['<img class="media invalid" data-src="." alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{..}')), [['<img class="media invalid" data-src=".." alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{../}')), [['<img class="media invalid" data-src="../" alt="">'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{/../b}')), [['<img class="media invalid" data-src="/../b" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{ttp://host}')), [['<img class="invalid" data-src="ttp://host" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{tel:1234567890}')), [['<img class="invalid" data-src="tel:1234567890" alt="">'], '']);
+      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0%1]}')), [['<img class="invalid" alt="">'], '']);
+      //assert.deepStrictEqual(inspect(parser('![]{http://[::ffff:0:0/96]}')), [['<img class="invalid" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{.}')), [['<img class="invalid" data-src="." alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{..}')), [['<img class="invalid" data-src=".." alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{../}')), [['<img class="invalid" data-src="../" alt="">'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{/../b}')), [['<img class="invalid" data-src="/../b" alt="">'], '']);
       assert.deepStrictEqual(inspect(parser(' ![]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{/}')), undefined);
     });
@@ -69,6 +71,8 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]{  b }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{  b  }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{  b   }')), [['<a href="b" target="_blank"><img class="media" data-src="b" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{"}"}')), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt=""></a>'], '"}']);
       assert.deepStrictEqual(inspect(parser('![]{\\}')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\ }')), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt=""></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{\\b}')), [['<a href="\\b" target="_blank"><img class="media" data-src="\\b" alt=""></a>'], '']);

package/src/parser/inline/media.ts

@@ -5,7 +5,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 { markInvalid } from '../util';
+import { invalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { push } from 'spica/array';
 import { html, define } from 'typed-dom/dom';
@@ -51,7 +51,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, false, vali
       || (cache = context.caches?.media?.get(url.href)?.cloneNode(true))
       || html('img', { class: 'media', 'data-src': url.source, alt: text });
     assert(!el.matches('.invalid'));
-    cache?.hasAttribute('alt') && cache?.setAttribute('alt', text);
+    cache?.hasAttribute('alt') && cache.setAttribute('alt', text);
     if (!sanitize(el, url, text)) return [[el], rest];
     assert(!el.matches('.invalid'));
     define(el, attributes('media', push([], el.classList), optspec, params));
@@ -98,19 +98,25 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
     case 'https:':
       assert(uri.host);
       if (/\/\.\.?(?:\/|$)/.test('/' + uri.source.slice(0, uri.source.search(/[?#]|$/)))) {
-        markInvalid(target, 'media', 'argument',
-          'Dot-segments cannot be used in media paths; use subresource paths instead');
+        define(target, {
+          class: 'invalid',
+          ...invalid('media', 'argument',
+            'Dot-segments cannot be used in media paths; use subresource paths instead')
+        });
         return false;
       }
       break;
     default:
-      markInvalid(target, 'media', 'argument', 'Invalid protocol');
+      define(target, { class: 'invalid', ...invalid('media', 'argument', 'Invalid protocol') });
       return false;
   }
-  if (alt.includes(Command.Escape)) {
-    define(target, { alt: target.getAttribute('alt')?.replace(CmdRegExp.Escape, '') });
-    markInvalid(target, 'media', 'content',
-      `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`);
+  if (alt.includes(Command.Error)) {
+    define(target, {
+      class: 'invalid',
+      alt: target.getAttribute('alt')?.replace(CmdRegExp.Error, ''),
+      ...invalid('media', 'argument',
+      `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`)
+    });
     return false;
   }
   return true;

package/src/parser/inline/reference.ts

@@ -6,9 +6,10 @@ import { str } from '../source';
 import { blank, trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
+import { invalid } from '../util';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, false, surround(
-  '[[',
+  str('[['),
   precedence(1, state(State.annotation | State.reference | State.media,
   subsequence([
     abbr,
@@ -38,12 +39,7 @@ const abbr: ReferenceParser.AbbrParser = surround(
 function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
   switch (ns[0]) {
     case '':
-      return {
-        class: 'invalid',
-        'data-invalid-syntax': 'reference',
-        'data-invalid-type': 'syntax',
-        'data-invalid-message': 'Invalid abbreviation',
-      };
+      return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
     case '\n':
       const abbr = ns[1] as string;
       ns[0] = ns[1] = '';

package/src/parser/inline/ruby.ts

@@ -5,6 +5,7 @@ import { sequence, surround, dup, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
 import { isTightNodeStart } from '../visibility';
+import { invalid } from '../util';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -100,13 +101,11 @@ function attributes(texts: string[], rubies: string[]): Record<string, string> {
   let attrs: Record<string, string> | undefined;
   for (const ss of [texts, rubies]) {
     for (let i = 0; i < ss.length; ++i) {
-      if (!ss[i].includes(Command.Escape)) continue;
-      ss[i] = ss[i].replace(CmdRegExp.Escape, '');
+      if (!ss[i].includes(Command.Error)) continue;
+      ss[i] = ss[i].replace(CmdRegExp.Error, '');
       attrs ??= {
         class: 'invalid',
-        'data-invalid-syntax': 'ruby',
-        'data-invalid-type': ss === texts ? 'content' : 'argument',
-        'data-invalid-message': 'Invalid HTML entity',
+        ...invalid('ruby', ss === texts ? 'content' : 'argument', 'Invalid HTML entity'),
       };
     }
   }

package/src/parser/inline.test.ts

@@ -72,6 +72,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('***a*b*c***')), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('*(*a*)*')), [['<em><span class="paren">(<em>a</em>)</span></em>'], '']);
       assert.deepStrictEqual(inspect(parser('**(**a**)**')), [['<strong><span class="paren">(<strong>a</strong>)</span></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('*<*>')), [['<em>&lt;</em>', '>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++ ++*')), [['<em><ins> </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++ a ++*')), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++  a  ++*')), [['<em><ins>  a  </ins></em>'], '']);
@@ -81,9 +84,6 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>[#</bdi>]')), [['<bdi>[#</bdi>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"<bdi>("")</bdi>')), [['"', '<bdi><span class="paren">("")</span></bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('*[*]')), [['*', '[', '*', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('*<*>')), [['<em>&lt;</em>', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a((b))*')), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
       assert.deepStrictEqual(inspect(parser('++\na\n++\n~~\nb\n~~\nc')), [['<ins><br>a</ins>', '<br>', '<del><br>b</del>', '<br>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('``a`')), [['``', 'a', '`'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]')), [['[', '<a class="account" href="/@a">@a</a>', ']'], '']);
@@ -127,6 +127,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('((${))}$')), [['(', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('((a\nb))')), [['<span class="paren">(<span class="paren">(a<br>b)</span>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(((a\nb)))')), [['<span class="paren">(<span class="paren">(<span class="paren">(a<br>b)</span>)</span>)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(([[a] ]))')), [['<sup class="annotation"><span>[[a] ]</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(([["*(*"] ]))')), [['<sup class="annotation"><span>[["*(*"] ]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('(([:a\n]')), [['(', '(', '<span class="invalid">a<br></span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '(', '(', '"', '"', ')', ')'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);

package/src/parser/source/escapable.test.ts

@@ -20,13 +20,13 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
     });
 
     it('\\', () => {
@@ -39,7 +39,7 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\$')), [['\\$'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
     });
 
   });

package/src/parser/source/escapable.ts

@@ -20,19 +20,25 @@ export const escsource: EscapableSourceParser = ({ source, context }) => {
           consume(-1, context);
           return [[], source.slice(1)];
         case Command.Escape:
+          assert(false);
           consume(1, context);
           return [[source.slice(1, 2)], source.slice(2)];
         case '\\':
           switch (source[1]) {
             case undefined:
+              return [[source[0]], ''];
             case '\n':
               return [[source[0]], source.slice(1)];
             default:
               consume(1, context);
               return [[source.slice(0, 2)], source.slice(2)];
           }
+        case '\n':
+          assert(false);
+          return [[source[0]], source.slice(1)];
         default:
-          const b = source[0] !== '\n' && source[0].trimStart() === '';
+          assert(source[0] !== '\n');
+          const b = source[0].trimStart() === '';
           const i = b
             ? source.search(nonWhitespace)
             : 1;

package/src/parser/source/str.ts

@@ -19,11 +19,9 @@ export function str(pattern: string | RegExp, not?: string): Parser<string, Cont
     : ({ source, context }) => {
         if (source === '') return;
         const m = source.match(pattern);
-        count && m && consume(m[0].length, context);
-        if (m && not && source.slice(m[0].length, m[0].length + not.length) === not) return;
-        //assert(!m || m[0]);
-        return m
-          ? [[m[0]], source.slice(m[0].length)]
-          : undefined;
+        if (m === null) return;
+        count && consume(m[0].length, context);
+        if (not && source.slice(m[0].length, m[0].length + not.length) === not) return;
+        return [[m[0]], source.slice(m[0].length)];
       };
 }

package/src/parser/source/text.ts

@@ -27,6 +27,7 @@ export const text: TextParser = ({ source, context }) => {
         case '\\':
           switch (source[1]) {
             case undefined:
+              return [[], ''];
             case '\n':
               assert(source[0] !== Command.Escape);
               return [[], source.slice(1)];

package/src/parser/source/unescapable.test.ts

@@ -20,13 +20,13 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '\n'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('\n\n')), [['\n', '\n'], '']);
     });
 
     it('\\', () => {
@@ -39,7 +39,7 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('\\`')), [['\\', '`'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\', '　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
+      //assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
     });
 
   });

package/src/parser/source/unescapable.ts

@@ -18,17 +18,22 @@ export const unescsource: UnescapableSourceParser = ({ source, context }) => {
           consume(-1, context);
           return [[], source.slice(1)];
         case Command.Escape:
-          assert(source[0] !== Command.Escape);
+          assert(false);
           consume(1, context);
           return [[source.slice(1, 2)], source.slice(2)];
+        case '\n':
+          assert(false);
+          return [[source[0]], source.slice(1)];
+        default:
+          assert(source[0] !== '\n');
+          const b = source[0].trimStart() === '';
+          const i = b || isAlphanumeric(source[0])
+            ? source.search(b ? nonWhitespace : nonAlphanumeric) || 1
+            : 1;
+          assert(i > 0);
+          consume(i - 1, context);
+          return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
       }
-      const b = source[0] !== '\n' && source[0].trimStart() === '';
-      const i = b || isAlphanumeric(source[0])
-        ? source.search(b ? nonWhitespace : nonAlphanumeric) || 1
-        : 1;
-      assert(i > 0);
-      consume(i - 1, context);
-      return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
     }
     default:
       consume(i, context);

package/src/parser/util.ts

@@ -75,6 +75,18 @@ export function repeat<T extends HTMLElement | string>(symbol: string, parser: P
   };
 }
 
+export function invalid(
+  syntax: string,
+  type: string,
+  message: string,
+): Record<string, string> {
+  return {
+    'data-invalid-syntax': syntax,
+    'data-invalid-type': type,
+    'data-invalid-message': message,
+  };
+}
+
 export function markInvalid<T extends Element>(
   el: T,
   syntax: string,

package/src/parser/visibility.ts

@@ -5,7 +5,6 @@ import { union, some, verify, convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { linebreak, unescsource } from './source';
 import { invisibleHTMLEntityNames } from './api/normalize';
-import { reduce } from 'spica/memoize';
 import { push } from 'spica/array';
 
 export namespace blank {
@@ -78,7 +77,7 @@ export function tightStart<T>(parser: Parser<T>, except?: string): Parser<T> {
       ? parser(input)
       : undefined;
 }
-const isTightStart = reduce((input: Input<MarkdownParser.Context>, except?: string): boolean => {
+function isTightStart(input: Input<MarkdownParser.Context>, except?: string): boolean {
   const { source } = input;
   if (source === '') return true;
   if (except && source.slice(0, except.length) === except) return false;
@@ -109,7 +108,7 @@ const isTightStart = reduce((input: Input<MarkdownParser.Context>, except?: stri
     default:
       return source[0].trimStart() !== '';
   }
-}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
+}
 
 export function isLooseNodeStart(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;