securemark 0.235.2 → 0.237.0

package/src/parser/block/reply/quote.ts

@@ -26,7 +26,7 @@ export const quote: ReplyParser.QuoteParser = lazy(() => creator(block(fmap(vali
             class: 'quote invalid',
             'data-invalid-syntax': 'quote',
             'data-invalid-type': 'syntax',
-            'data-invalid-description': `Missing the whitespace after "${ns[0].split(/[^>]/, 1)[0]}".`,
+            'data-invalid-message': `Missing the whitespace after "${ns[0].split(/[^>]/, 1)[0]}"`,
           },
       defrag(ns)),
     html('br'),

package/src/parser/block/table.ts

@@ -31,7 +31,7 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
       class: 'invalid',
       'data-invalid-syntax': 'tablerow',
       'data-invalid-type': 'syntax',
-      'data-invalid-description': 'Invalid table row.',
+      'data-invalid-message': 'Invalid table row',
     }, [html('td', source.replace('\n', ''))])
   ], ''])));
 

package/src/parser/block/ulist.test.ts

@@ -66,6 +66,14 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('- [X] 1')), [['<ul class="checklist"><li><span class="checkbox">☑</span>1</li></ul>'], '']);
     });
 
+    it('indexer', () => {
+      assert.deepStrictEqual(inspect(parser('- [#a]')), [['<ul><li><a class="index" href="#index:a">a</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [#b]')), [['<ul><li id="index:b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] [#a]')), [['<ul class="checklist"><li><span class="checkbox">☐</span><a class="index" href="#index:a">a</a></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- [ ] a [#b]')), [['<ul class="checklist"><li id="index:b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- a [#b]\n - c [#d]')), [['<ul><li id="index:b">a<span class="indexer" data-index="b"></span><ul><li id="index:d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);
+    });
+
   });
 
 });

package/src/parser/block/ulist.ts

@@ -2,7 +2,7 @@ import { UListParser } from '../block';
 import { union, inits, subsequence, some, block, line, validate, indent, focus, rewrite, context, creator, open, trim, trimStart, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_ } from './ilist';
-import { inline } from '../inline';
+import { inline, indexer, indexee } from '../inline';
 import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 import { contentline } from '../source';
@@ -15,13 +15,13 @@ export const ulist: UListParser = lazy(() => block(validate(
 export const ulist_: UListParser = lazy(() => block(fmap(validate(
   /^-(?=$|\s)/,
   some(creator(union([
-    fmap(fallback(
+    indexee(fmap(fallback(
       inits([
-        line(open(/^-(?:$|\s)/, trim(subsequence([checkbox, trimStart(some(inline))])), true)),
+        line(open(/^-(?:$|\s)/, trim(subsequence([checkbox, trimStart(some(union([indexer, inline])))])), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
-      iitem),
-      ns => [html('li', defrag(fillFirstLine(ns)))]),
+      invalid),
+      ns => [html('li', defrag(fillFirstLine(ns)))]), true),
   ])))),
   es => [format(html('ul', es))])));
 
@@ -31,12 +31,12 @@ export const checkbox = focus(
     html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
   ], '']);
 
-const iitem = rewrite(contentline, source => [[
+const invalid = rewrite(contentline, source => [[
   html('span', {
     class: 'invalid',
     'data-invalid-syntax': 'listitem',
     'data-invalid-type': 'syntax',
-    'data-invalid-description': 'Fix the indent or the head of the list item.',
+    'data-invalid-message': 'Fix the indent or the head of the list item',
   }, source.replace('\n', ''))
 ], '']);
 

package/src/parser/header.ts

@@ -31,7 +31,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
               translate: 'no',
               'data-invalid-syntax': 'header',
               'data-invalid-type': 'syntax',
-              'data-invalid-description': 'Invalid syntax.',
+              'data-invalid-message': 'Invalid syntax',
             }, normalize(source)),
           ], ''],
         ]))),

package/src/parser/inline/deletion.ts

@@ -9,7 +9,7 @@ import { unshift } from 'spica/array';
 export const deletion: DeletionParser = lazy(() => creator(surround(
   str('~~'),
   some(union([
-    some(inline, blank(/\n?/, /~~/)),
+    some(inline, blank(/\n?/, '~~')),
     open(/^\n?/, some(inline, '~'), true),
   ])),
   str('~~'), false,

package/src/parser/inline/emphasis.ts

@@ -11,7 +11,7 @@ export const emphasis: EmphasisParser = lazy(() => creator(surround(
   str('*'),
   startTight(some(union([
     strong,
-    some(inline, blank('', /\*/)),
+    some(inline, blank('', '*')),
     open(some(inline, '*'), inline),
   ])), '*'),
   str('*'), false,

package/src/parser/inline/emstrong.ts

@@ -10,19 +10,19 @@ import { html, defrag } from 'typed-dom';
 import { unshift } from 'spica/array';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
-  some(inline, blank('', /\*\*/)),
+  some(inline, blank('', '**')),
   open(some(inline, '*'), inline),
 ])));
 const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   strong,
-  some(inline, blank('', /\*/)),
+  some(inline, blank('', '*')),
   open(some(inline, '*'), inline),
 ])));
 
 export const emstrong: EmStrongParser = lazy(() => creator(surround(
   str('***'),
   startTight(some(union([
-    some(inline, blank('', /\*/)),
+    some(inline, blank('', '*')),
     open(some(inline, '*'), inline),
   ]))),
   str(/^\*{1,3}/), false,

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

@@ -4,9 +4,9 @@ import { Parser } from '../../../combinator/data/parser';
 import { fmap } from '../../../combinator';
 import { define } from 'typed-dom';
 
-export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P): P;
-export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>): Parser<HTMLElement> {
-  return fmap(parser, ([el], _, { id }) => [define(el, { id: id !== '' && identity(text(el)) || undefined })]);
+export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parser: P, optional?: boolean): P;
+export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>, optional?: boolean): Parser<HTMLElement> {
+  return fmap(parser, ([el], _, { id }) => [define(el, { id: id !== '' && identity(text(el, optional)) || undefined })]);
 }
 
 export function identity(text: string): string {
@@ -18,13 +18,13 @@ assert(identity('0'.repeat(100)).slice(6) === '0'.repeat(100));
 assert(identity('0'.repeat(101)).slice(6) === '0'.repeat(97) + '...');
 assert(identity('0'.repeat(200)).slice(6) === '0'.repeat(97) + '...');
 
-export function text(source: HTMLElement | DocumentFragment): string {
+export function text(source: HTMLElement | DocumentFragment, optional = false): string {
   assert(source instanceof DocumentFragment || !source.matches('.indexer'));
-  assert(source.querySelectorAll('.indexer').length <= 1);
-  assert(source.querySelector('.indexer') === source.querySelector(':scope > .indexer'));
-  assert(!source.querySelector('.annotation, br'));
-  const indexer = source.querySelector('.indexer');
+  assert(source.querySelectorAll(':scope > .indexer').length <= 1);
+  const indexer = source.querySelector(':scope > .indexer');
   if (indexer) return indexer.getAttribute('data-index')!;
+  if (optional) return '';
+  assert(!source.querySelector('.annotation, br'));
   const target = source.cloneNode(true) as typeof source;
   for (
     let es = target.querySelectorAll('code[data-src], .math[data-src], .comment, rt, rp, .reference'),

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

@@ -19,7 +19,7 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => creator
       class: 'invalid',
       'data-invalid-syntax': 'extension',
       'data-invalid-type': 'syntax',
-      'data-invalid-description': 'Invalid symbol.',
+      'data-invalid-message': 'Invalid symbol',
     }, defrag(bs)),
   ], rest],
   ([as, bs], rest) => [unshift(as, bs), rest]))));

package/src/parser/inline/html.ts

@@ -116,38 +116,38 @@ function elem(tag: string, as: string[], bs: (HTMLElement | string)[], cs: strin
   assert(as[0][0] === '<' && as[as.length - 1].slice(-1) === '>');
   assert(bs.length === defrag(bs).length);
   assert(cs.length === 1);
-  if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag <${tag}>.`, as, bs, cs);
+  if (!tags.includes(tag)) return invalid('tag', `Invalid HTML tag <${tag}>`, as, bs, cs);
   switch (tag) {
     case 'sup':
     case 'sub':
       switch (true) {
         case context.state?.in?.supsub:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup> or <sub> HTML tag.`, as, bs, cs);
+          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup> or <sub> HTML tag`, as, bs, cs);
       }
       break;
     case 'small':
       switch (true) {
         case context.state?.in?.supsub:
         case context.state?.in?.small:
-          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup>, <sub>, or <small> HTML tag.`, as, bs, cs);
+          return invalid('nest', `<${tag}> HTML tag cannot be used in <sup>, <sub>, or <small> HTML tag`, as, bs, cs);
       }
       break;
   }
   let attrs: Record<string, string | undefined> | undefined;
   switch (true) {
     case 'data-invalid-syntax' in (attrs = attributes('html', [], attrspec[tag], as.slice(1, -1) as string[])):
-      return invalid('attribute', 'Invalid HTML attribute.', as, bs, cs);
+      return invalid('attribute', 'Invalid HTML attribute', as, bs, cs);
     default:
       assert(attrs);
       return h(tag as 'span', attrs, bs);
   }
 }
-function invalid(type: string, description: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
+function invalid(type: string, message: string, as: (HTMLElement | string)[], bs: (HTMLElement | string)[], cs: (HTMLElement | string)[]): HTMLElement {
   return h('span', {
     class: 'invalid',
     'data-invalid-syntax': 'html',
     'data-invalid-type': type,
-    'data-invalid-description': description,
+    'data-invalid-message': message,
   }, defrag(push(unshift(as, bs), cs)));
 }
 
@@ -187,7 +187,7 @@ export function attributes(
     attrs['class'] = join(classes, ' ');
     attrs['data-invalid-syntax'] = syntax;
     attrs['data-invalid-type'] = 'argument';
-    attrs['data-invalid-description'] = 'Invalid argument.';
+    attrs['data-invalid-message'] = 'Invalid argument';
   }
   return attrs;
 }

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

@@ -14,7 +14,6 @@ describe('Unit: parser/inline/htmlentity', () => {
       assert.deepStrictEqual(inspect(parser('& ;')), undefined);
       assert.deepStrictEqual(inspect(parser('&\n;')), undefined);
       assert.deepStrictEqual(inspect(parser('&a;')), [['<span class="invalid">&amp;a;</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('&NewLine;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#g;')), undefined);
       assert.deepStrictEqual(inspect(parser('&#x;')), undefined);
@@ -36,6 +35,7 @@ describe('Unit: parser/inline/htmlentity', () => {
     });
 
     it('entity', () => {
+      assert.deepStrictEqual(inspect(parser('&NewLine;')), [[' '], '']);
       assert.deepStrictEqual(inspect(parser('&nbsp;')), [['\u00A0'], '']);
       assert.deepStrictEqual(inspect(parser('&amp;')), [['&'], '']);
       assert.deepStrictEqual(inspect(parser('&copy;')), [['©'], '']);

package/src/parser/inline/htmlentity.ts

@@ -1,24 +1,31 @@
+import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
 import { union, validate, focus, creator, fmap } from '../../combinator';
 import { html } from 'typed-dom';
+import { reduce } from 'spica/memoize';
 
 export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', focus(
-  /^&(?!NewLine;)[0-9A-Za-z]+;/,
-  (parser => entity => (
-    parser.innerHTML = entity,
-    entity = parser.textContent!,
-    [[`${entity[0] !== '&' || entity.length === 1 ? '' : '\0'}${entity}`], '']
-  ))(html('b')))));
+  /^&[0-9A-Za-z]+;/,
+  entity => [[parse(entity) ?? `\0${entity}`], ''])));
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([str]) => [
-    str[0] === '\0'
+  ([test]) => [
+    test[0] === '\0'
       ? html('span', {
           class: 'invalid',
           'data-invalid-syntax': 'htmlentity',
           'data-invalid-type': 'syntax',
-          'data-invalid-description': 'Invalid HTML entity.',
-        }, str.slice(1))
-      : str,
+          'data-invalid-message': 'Invalid HTML entity',
+        }, test.slice(1))
+      : test,
   ]);
+
+const parse = reduce((el => (entity: string): string | undefined => {
+  if (entity === '
') return ' ';
+  el.innerHTML = entity;
+  const text = el.textContent!;
+  return entity === text
+    ? undefined
+    : text;
+})(html('b')));

package/src/parser/inline/insertion.ts

@@ -9,7 +9,7 @@ import { unshift } from 'spica/array';
 export const insertion: InsertionParser = lazy(() => creator(surround(
   str('++'),
   some(union([
-    some(inline, blank(/\n?/, /\+\+/)),
+    some(inline, blank(/\n?/, '++')),
     open(/^\n?/, some(inline, '+'), true),
   ])),
   str('++'), false,

package/src/parser/inline/link.ts

@@ -103,7 +103,7 @@ function elem(
   origin: string,
 ): HTMLAnchorElement {
   let type: string;
-  let description: string;
+  let message: string;
   switch (uri.protocol) {
     case 'http:':
     case 'https:':
@@ -111,7 +111,7 @@ function elem(
       if (INSECURE_URI.slice(0, 2) === '^/' &&
           /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/)))) {
         type = 'argument';
-        description = 'Dot-segments cannot be used in subresource paths.';
+        message = 'Dot-segments cannot be used in subresource paths';
         break;
       }
       return html('a',
@@ -140,7 +140,7 @@ function elem(
           return html('a', { href: uri.source }, content);
       }
       type = 'content';
-      description = 'Invalid phone number.';
+      message = 'Invalid phone number';
       break;
   }
   return html('a',
@@ -148,7 +148,7 @@ function elem(
       class: 'invalid',
       'data-invalid-syntax': 'link',
       'data-invalid-type': type ??= 'argument',
-      'data-invalid-description': description ??= 'Invalid protocol.',
+      'data-invalid-message': message ??= 'Invalid protocol',
     },
     content.length === 0
       ? INSECURE_URI

package/src/parser/inline/mark.ts

@@ -9,7 +9,7 @@ import { unshift } from 'spica/array';
 export const mark: MarkParser = lazy(() => creator(surround(
   str('=='),
   startTight(some(union([
-    some(inline, blank('', /==/)),
+    some(inline, blank('', '==')),
     open(some(inline, '='), inline),
   ]))),
   str('=='), false,

package/src/parser/inline/math.ts

@@ -29,7 +29,7 @@ export const math: MathParser = lazy(() => creator(validate('$', rewrite(
             translate: 'no',
             'data-invalid-syntax': 'math',
             'data-invalid-type': 'content',
-            'data-invalid-description': `"${source.match(disallowedCommand)![0]}" command is disallowed.`,
+            'data-invalid-message': `"${source.match(disallowedCommand)![0]}" command is disallowed`,
           },
       source)
   ], '']))));

package/src/parser/inline/media.ts

@@ -81,7 +81,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
           class: void target.classList.add('invalid'),
           'data-invalid-syntax': 'media',
           'data-invalid-type': 'argument',
-          'data-invalid-description': 'Dot-segments cannot be used in media paths; use subresource paths instead.',
+          'data-invalid-message': 'Dot-segments cannot be used in media paths; use subresource paths instead',
         });
         return false;
       }
@@ -91,7 +91,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
         class: void target.classList.add('invalid'),
         'data-invalid-syntax': 'media',
         'data-invalid-type': 'argument',
-        'data-invalid-description': 'Invalid protocol.',
+        'data-invalid-message': 'Invalid protocol',
       });
       return false;
   }
@@ -100,7 +100,7 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
       class: void target.classList.add('invalid'),
       'data-invalid-syntax': 'media',
       'data-invalid-type': 'content',
-      'data-invalid-description': `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}".`,
+      'data-invalid-message': `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`,
       alt: target.getAttribute('alt')?.replace(/\0/g, ''),
     });
     return false;

package/src/parser/inline/reference.ts

@@ -46,7 +46,7 @@ function attributes(ns: (string | HTMLElement)[]): Record<string, string | undef
           class: 'invalid',
           'data-invalid-syntax': 'reference',
           'data-invalid-type': 'syntax',
-          'data-invalid-description': 'Invalid abbr.',
+          'data-invalid-message': 'Invalid abbr',
         }
       : { class: 'reference' };
 }

package/src/parser/inline/ruby.ts

@@ -83,13 +83,13 @@ 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('\0')) continue;
+      if (ss[i].indexOf('\0') === -1) continue;
       ss[i] = ss[i].replace(/\0/g, '');
       attrs ??= {
         class: 'invalid',
         'data-invalid-syntax': 'ruby',
         'data-invalid-type': ss === texts ? 'content' : 'argument',
-        'data-invalid-description': 'Invalid HTML entity.',
+        'data-invalid-message': 'Invalid HTML entity',
       };
     }
   }

package/src/parser/inline/strong.ts

@@ -9,7 +9,7 @@ import { unshift } from 'spica/array';
 export const strong: StrongParser = lazy(() => creator(surround(
   str('**'),
   startTight(some(union([
-    some(inline, blank('', /\*\*/)),
+    some(inline, blank('', '**')),
     open(some(inline, '*'), inline),
   ])), '*'),
   str('**'), false,

package/src/parser/inline.ts

@@ -75,5 +75,7 @@ export const inline: InlineParser = union([
   text
 ]);
 
+export { indexee } from './inline/extension/indexee';
+export { indexer } from './inline/extension/indexer';
 export { media } from './inline/media';
 export { shortmedia } from './inline/shortmedia';