securemark 0.239.0 → 0.240.2

package/src/parser/block/extension/figure.ts

@@ -46,7 +46,7 @@ export const segment: FigureParser.SegmentParser = block(match(
         ]),
       ]),
       closer),
-  ([, fence]) => fence.length)));
+  ([, fence]) => fence.length, [])));
 
 export const figure: FigureParser = block(rewrite(segment, fmap(
   convert(source => source.slice(source.search(/[[$]/), source.trimEnd().lastIndexOf('\n')),
@@ -76,10 +76,10 @@ export const figure: FigureParser = block(rewrite(segment, fmap(
     html('figure',
       attributes(label.getAttribute('data-label')!, param, content, caption),
       [
-        html('div', [content]),
         html('figcaption', unshift(
           [html('span', { class: 'figindex' })],
           defrag(caption))),
+        html('div', [content]),
       ])
   ])));
 
@@ -89,6 +89,7 @@ function attributes(label: string, param: string, content: HTMLElement, caption:
   switch (type || content.tagName) {
     case 'UL':
     case 'OL':
+    case 'checklist':
       type = 'list';
       break;
     case 'TABLE':
@@ -118,16 +119,45 @@ function attributes(label: string, param: string, content: HTMLElement, caption:
       'data-invalid-type': 'argument',
       'data-invalid-message': 'Invalid argument',
     } ||
-    group === '$' && (!content.classList.contains('math') || caption.length > 0) && {
-      'data-invalid-type': 'content',
-      'data-invalid-message': 'A figure labeled to define a formula number can contain only a math formula and no caption',
+    group === '$' && (type !== 'math' || caption.length > 0) && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"$" label group must be used to math formulas with no caption',
+    } ||
+    type === 'media' && {} ||
+    ['fig', 'figure'].includes(group) && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"fig" and "figure" label groups must be used to media',
+    } ||
+    group === 'table' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"table" label group must be used to tables',
+    } ||
+    group === 'list' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"list" label group must be used to lists',
+    } ||
+    group === 'quote' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"quote" label group must be used to blockquotes',
+    } ||
+    group === 'text' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"text" label group must be used to codeblocks with no language',
+    } ||
+    group === 'code' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"code" label group must be used to codeblocks with any language',
+    } ||
+    group === 'example' && type !== group && {
+      'data-invalid-type': 'label',
+      'data-invalid-message': '"example" label group must be used to examples',
     } ||
     undefined;
   return {
     'data-type': type,
     'data-label': label,
     'data-group': group,
-    ...invalid && {
+    ...invalid?.['data-invalid-type'] && {
       class: 'invalid',
       'data-invalid-syntax': 'figure',
       ...invalid,

package/src/parser/block/olist.ts

@@ -25,10 +25,10 @@ export const olist: OListParser = lazy(() => block(validate(
 export const olist_: OListParser = lazy(() => block(union([
   match(
     new RegExp(`^(?=${openers['.'].source.replace('?:', '')})`),
-    memoize(ms => list(type(ms[1]), '.'), ms => type(ms[1]))),
+    memoize(ms => list(type(ms[1]), '.'), ms => type(ms[1]).charCodeAt(0) || 0, [])),
   match(
     new RegExp(`^(?=${openers['('].source.replace('?:', '')})`),
-    memoize(ms => list(type(ms[1]), '('), ms => type(ms[1]))),
+    memoize(ms => list(type(ms[1]), '('), ms => type(ms[1]).charCodeAt(0) || 0, [])),
 ])));
 
 const list = (type: string, delim: string): OListParser.ListParser => fmap(

package/src/parser/header.test.ts

@@ -24,10 +24,10 @@ describe('Unit: parser/header', () => {
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---')), [['<details class="header" open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\n---\n')), [['<details class="header" open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details>'], '']);
-      assert.deepStrictEqual(inspect(parser('---\na: b\nC: d e\n---\n')), [['<details class="header" open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="C" data-value="d e"><span class="field-name">C</span>: <span class="field-value">d e</span>\n</span></details>'], '']);
-      assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na')), [['<details class="header" open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details>'], ' \r\na']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\nC: D e\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na')), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], ' \r\na']);
     });
 
   });

package/src/parser/header.ts

@@ -20,10 +20,12 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
             fmap(
               some(union([field])),
               es => [
-                html('details', { class: 'header', open: '' }, defrag([
-                  html('summary', 'Header'),
-                  ...es,
-                ])),
+                html('aside', { class: 'header' }, [
+                  html('details', { open: '' }, defrag([
+                    html('summary', 'Header'),
+                    ...es,
+                  ])),
+                ]),
               ])))),
           source => [[
             html('pre', {
@@ -42,7 +44,7 @@ const field: MarkdownParser.HeaderParser.FieldParser = line(source => {
   const name = source.slice(0, source.indexOf(':'));
   const value = source.slice(name.length + 1).trim();
   return [[
-    html('span', { class: 'field', 'data-name': name, 'data-value': value }, [
+    html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),

package/src/parser/inline/annotation.ts

@@ -19,7 +19,7 @@ export const annotation: AnnotationParser = lazy(() => creator(validate('((', ')
     //label: true,
     //link: true,
     //autolink: true,
-  }}, state: undefined },
+  }}, state: undefined, delimiters: undefined },
   trimSpaceStart(union([some(inline, ')', /^\\?\n/)]))))),
   '))'),
   ns => [html('sup', { class: 'annotation' }, trimNodeEnd(defrag(ns)))]))));

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

@@ -16,12 +16,16 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(1)')), [['(', '1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(10)')), [['(', '10', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(2000)')), [['(', '2000', ')'], '']);
-      assert.deepStrictEqual(inspect(parser('(0-1)')), [['<span class="paren">(0-1)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('(1, 2)')), [['(', '1, 2', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(0-1)')), [['(', '0-1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(0)-1')), [['(', '0', ')'], '-1']);
       assert.deepStrictEqual(inspect(parser('(0.1)')), [['(', '0.1', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(0.1.2)')), [['(', '0.1.2', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(1.1, 1.2-1.3, 1.4)')), [['(', '1.1, 1.2-1.3, 1.4', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(a)')), [['(', 'a', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(A)')), [['(', 'A', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('（１，２）')), [['（', '１，２', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（０－１）')), [['（', '０－１', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（０．１）（Ａ）')), [['（', '０．１', '）', '（', 'Ａ', '）'], '']);
     });
 

package/src/parser/inline/bracket.ts

@@ -6,14 +6,14 @@ import { str } from '../source';
 import { html, defrag } from 'typed-dom';
 import { unshift, push } from 'spica/array';
 
-const index = /^(?:[0-9]+(?:\.[0-9]+)*|[A-Za-z])/;
+const index = /^(?:[0-9]+(?:(?:[.-]|, )[0-9]+)*|[A-Za-z])/;
 
 export const bracket: BracketParser = lazy(() => creator(union([
   surround(str('('), str(index), str(')')),
   surround(str('('), some(inline, ')'), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  surround(str('（'), str(new RegExp(index.source.replace(/[09AZaz.]/g, c => String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）')),
+  surround(str('（'), str(new RegExp(index.source.replace(/[09AZaz., ]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）')),
   surround(str('（'), some(inline, '）'), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest]),

package/src/parser/inline/comment.ts

@@ -21,4 +21,4 @@ export const comment: CommentParser = lazy(() => creator(validate('[#', match(
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length)))));
+  ([, fence]) => fence.length, [])))));

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

@@ -64,16 +64,16 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^a|]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a,|]]')), [['<sup class="reference" data-abbr="a,"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a |]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a|b]]')), [['<sup class="invalid">^a|b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|b ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|b  ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>]]')), [['<sup class="invalid">^a|</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|<wbr>b]]')), [['<sup class="invalid">^a|<wbr>b</sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^a|^b]]')), [['<sup class="reference" data-abbr="a">^b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a| b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| b ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| b  ]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^a|  ]]')), [['<sup class="reference" data-abbr="a"></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a|  b]]')), [['<sup class="reference" data-abbr="a">b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| <wbr>]]')), [['<sup class="invalid">^a|</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| <wbr>b]]')), [['<sup class="invalid">^a| <wbr>b</sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^a| ^b]]')), [['<sup class="reference" data-abbr="a">^b</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1]]')), [['<sup class="invalid">^1</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1a]]')), [['<sup class="reference" data-abbr="1a"></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1 ]]')), [['<sup class="invalid">^1</sup>'], '']);

package/src/parser/inline/reference.ts

@@ -19,7 +19,7 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
     //label: true,
     //link: true,
     //autolink: true,
-  }}, state: undefined },
+  }}, state: undefined, delimiters: undefined },
   subsequence([
     abbr,
     focus(/^\^[^\S\n]*/, source => [['', source], '']),
@@ -31,7 +31,7 @@ export const reference: ReferenceParser = lazy(() => creator(validate('[[', ']]'
 const abbr: ReferenceParser.AbbrParser = creator(fmap(verify(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
-  /^\|?(?=]])|^\|[^\S\n]+/),
+  /^\|?(?=]])|^\|[^\S\n]*/),
   (_, rest, context) => isStartLoose(rest, context)),
   ([source]) => [html('abbr', source)]));
 

package/src/parser/inline.test.ts

@@ -144,6 +144,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span class="paren">((a))</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation">""</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference">a</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference">[[a]]</sup>'], '']);
@@ -151,6 +152,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><a href="a">a</a></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><a href="b">a</a></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference">""</sup>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);
       assert.deepStrictEqual(inspect(parser('<<small>a<</small>')), [['<', '<small>a&lt;</small>'], '']);
       assert.deepStrictEqual(inspect(parser('<sup><sub>a</sub>')), [['<', 'sup', '>', '<sub>a</sub>'], '']);
@@ -162,6 +164,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('"[# *"*"*')), [['"', '[#', ' ', '*', '"', '*', '"', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('"[# "*"* #]')), [['"', '[#', ' ', '"', '*', '"', '*', ' ', '#', ']'], '']);
     });
 
     it('uri', () => {