securemark 0.244.1 → 0.246.0

package/global.test.d.ts

@@ -1,7 +1,11 @@
 import assert from 'power-assert';
 
-type Assert = typeof assert;
+declare namespace NS {
+  export {
+    assert,
+  }
+}
 
 declare global {
-  const assert: Assert;
+  const assert: typeof NS.assert;
 }

package/index.ts

@@ -0,0 +1,4 @@
+import 'spica/global';
+export * from './src/parser';
+export * from './src/util';
+export * from './src/renderer';

package/karma.conf.js

@@ -1,48 +1,30 @@
 module.exports = function (config) {
   config.set({
-    basePath: '',
+    browsers: ['Chrome', 'Firefox'],
     frameworks: ['mocha'],
     files: [
-      { pattern: 'https://cdn.polyfill.io/v3/polyfill.js?flags=gated&features=default', watched: false, served: false, included: true },
-      { pattern: 'https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js', watched: false, served: false, included: true },
-      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/prism/1.22.0/prism.js', watched: false, served: false, included: true },
-      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/prism/1.22.0/plugins/autoloader/prism-autoloader.min.js', watched: false, served: false, included: true },
-      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.2.0/es5/tex-chtml.min.js', watched: false, served: false, included: true },
-      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.2.2/purify.js', watched: false, served: false, included: true },
-      { pattern: 'node_modules/power-assert/build/power-assert.js', watched: true, served: true, included: true },
-      { pattern: 'dist/*.test.js', watched: true, served: true, included: true }
+      { pattern: 'https://cdn.jsdelivr.net/npm/power-assert@1.6.1/build/power-assert.js', watched: false, served: false, included: true, integrity: 'sha256-MuDC5CQFh3oWtiG0YE000HlkK08xAilD2v0ndZR+Kds=' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.js', watched: false, served: false, included: true, integrity: 'sha512-2iwCHjuj+PmdCyvb88rMOch0UcKQxVHi/gsAml1fN3eg82IDaO/cdzzeXX4iF2VzIIes7pODE1/G0ts3QBwslA==' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/benchmark/2.1.4/benchmark.js', watched: false, served: false, included: true, integrity: 'sha512-XnVGk21Ij51MbU8XezQpkwZ1/GA8b5qmoVGIOdJLBYycutjkaeemipzRJP7P6mEJl99OfnweA7M3e4WLfuG7Aw==' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.js', watched: false, served: false, included: true, integrity: 'sha512-n/4gHW3atM3QqRcbCn6ewmpxcLAHGaDjpEBu4xZd47N0W2oQ+6q7oc3PXstrJYXcbNU1OHdQ1T7pAP+gi5Yu8g==' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/prism/1.28.0/prism.min.js', watched: false, served: false, included: true, integrity: 'https://cdnjs.cloudflare.com/ajax/libs/prism/1.22.0/prism.js' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/prism/1.28.0/plugins/autoloader/prism-autoloader.min.js', watched: false, served: false, included: true, integrity: 'sha512-fTl/qcO1VgvKtOMApX2PdZzkziyr2stM65GYPLGuYMnuMm1z2JLJG6XVU7C/mR+E7xBUqCivykuhlzfqxXBXbg==' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.2.0/es5/tex-chtml.min.js', watched: false, served: false, included: true, integrity: 'sha512-93xLZnNMlYI6xaQPf/cSdXoBZ23DThX7VehiGJJXB76HTTalQKPC5CIHuFX8dlQ5yzt6baBQRJ4sDXhzpojRJA==' },
+      { pattern: 'https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.3.8/purify.js', watched: false, served: false, included: true, integrity: 'sha512-QaF+0tDlqVmwZaQSc0kImgYmw+Cd66TxA5D9X70I5V9BNSqk6yBTbyqw2VEUsVYV5OTbxw8HD9d45on1wvYv7g==' },
+      { pattern: 'dist/**/*.{js,map}', watched: true, served: true, included: true },
     ],
-    exclude: [
-    ],
-    espowerPreprocessor: {
-      options: {
-        emitActualCode: false,
-        ignoreUpstreamSourceMap: true
-      }
+    reporters: ['dots', 'coverage'],
+    preprocessors: {
+      'dist/**/*.js': ['coverage'],
     },
-    reporters: ['dots'],
-    coverageIstanbulReporter: {
-      reports: ['html', 'lcovonly', 'text-summary'],
+    coverageReporter: {
       dir: 'coverage',
-      combineBrowserReports: true,
-      skipFilesWithNoCoverage: false,
-      verbose: false,
-      'report-config': {
-        html: {
-          subdir: 'html',
-        },
-      },
-      instrumentation: {
-        'default-excludes': false,
-      },
-    },
-    coverageIstanbulInstrumenter: {
-      esModules: true,
+      reporters: [
+        { type: 'html', subdir: browser => browser.split(/\s/)[0] },
+        { type: 'text-summary', subdir: '.', file: 'summary.txt' },
+      ],
     },
-    autoWatch: true,
-    autoWatchBatchDelay: 500,
-    browserDisconnectTimeout: 30000,
-    browsers: ['Chrome'],
-    singleRun: true,
+    browserDisconnectTimeout: 60 * 1e3,
+    browserNoActivityTimeout: 90 * 1e3,
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.244.1",
+  "version": "0.246.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -13,22 +13,20 @@
     "latex"
   ],
   "types": "./index.d.ts",
-  "main": "./dist/securemark.js",
+  "main": "./dist/index.js",
   "files": [
     "dist",
-    "*.d.ts",
+    "index.*",
     "src",
     "test",
+    "*.ts",
     "*.js",
     "*.json",
+    "*.map",
     "*.md",
     "NOTICE",
     "LICENSE"
   ],
-  "browserify-shim": {
-    "prismjs": "global:Prism",
-    "dompurify": "global:DOMPurify"
-  },
   "devDependencies": {
     "@types/dompurify": "2.3.3",
     "@types/jquery": "3.5.14",
@@ -36,41 +34,37 @@
     "@types/mocha": "9.1.1",
     "@types/power-assert": "1.5.8",
     "@types/prismjs": "1.26.0",
-    "browserify": "^17.0.0",
-    "browserify-shim": "^3.8.14",
-    "concurrently": "^7.1.0",
-    "del": "^6.0.0",
-    "eslint-plugin-redos": "^4.3.0",
-    "gulp": "^4.0.2",
-    "gulp-derequire": "^3.0.0",
-    "gulp-eslint": "^6.0.0",
-    "gulp-footer": "^2.1.0",
-    "gulp-header": "^2.0.9",
-    "gulp-load-plugins": "^2.0.7",
-    "gulp-mocha": "^8.0.0",
-    "gulp-rename": "^2.0.0",
-    "gulp-unassert": "^2.0.0",
-    "karma": "^6.3.19",
+    "@typescript-eslint/parser": "^5.25.0",
+    "babel-loader": "^8.2.5",
+    "babel-plugin-unassert": "^3.2.0",
+    "concurrently": "^7.2.0",
+    "eslint": "^8.15.0",
+    "eslint-plugin-redos": "^4.4.0",
+    "eslint-webpack-plugin": "^3.1.1",
+    "glob": "^8.0.3",
+    "karma": "^6.3.20",
     "karma-chrome-launcher": "^3.1.1",
-    "karma-coverage-istanbul-instrumenter": "^1.0.4",
-    "karma-coverage-istanbul-reporter": "^3.0.3",
-    "karma-espower-preprocessor": "^1.2.0",
+    "karma-coverage": "^2.2.0",
     "karma-firefox-launcher": "^2.1.2",
     "karma-mocha": "^2.0.1",
     "mocha": "^10.0.0",
-    "npm-check-updates": "^12.5.11",
-    "power-assert": "^1.6.1",
+    "npm-check-updates": "^13.0.1",
     "semver": "^7.3.7",
-    "spica": "0.0.540",
-    "tsify": "^5.0.4",
-    "typed-dom": "0.0.272",
-    "typed-query-selector": "^2.6.1",
+    "spica": "0.0.550",
+    "ts-loader": "^9.3.0",
+    "typed-dom": "^0.0.292",
     "typescript": "4.6.4",
-    "vinyl-buffer": "^1.0.1",
-    "vinyl-source-stream": "^2.0.0"
+    "webpack": "^5.72.1",
+    "webpack-cli": "^4.9.2",
+    "webpack-merge": "^5.8.0"
   },
   "scripts": {
-    "test": "gulp test"
+    "update": "ncu -u && npm i --no-shrinkwrap && bundle update",
+    "dev": "concurrently \"webpack --env mode=test -w\" \"karma start --auto-watch --reporters dots\" \"webpack --env mode=dist -w --output-path ./gh-pages/assets/dist\" \"bundle exec jekyll serve -s ./gh-pages -d ./gh-pages/_site --incremental\"",
+    "test": "webpack --env mode=test && karma start --single-run --concurrency 1",
+    "lint": "webpack --env mode=lint",
+    "bench": "webpack --env mode=bench && karma start --single-run --concurrency 1 --reporters dots",
+    "dist": "webpack --env mode=dist"
   },
   "author": "falsandtru",
   "license": "UNLICENSED"

package/src/parser/block/extension/table.test.ts

@@ -10,20 +10,6 @@ describe('Unit: parser/block/extension/table', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('~~~table a\n-\n~~~')), [['<pre class="invalid" translate="no">~~~table a\n-\n~~~</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(`~~~table\n0${'\n'.repeat(10001)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
-      assert.deepStrictEqual(
-        inspect(parser([
-          '~~~table',
-          `${[...Array(33)].map((_, i) => `${i + 1}`).join('\n')}`,
-          '~~~'
-        ].join('\n'))),
-        [[`<pre class="invalid" translate="no">~~~table\n${[...Array(33)].map((_, i) => `${i + 1}`).join('\n')}\n~~~</pre>`], '']);
-      assert.deepStrictEqual(
-        inspect(parser([
-          '~~~table',
-          '::33 1',
-          '~~~'
-        ].join('\n'))),
-        [[`<pre class="invalid" translate="no">~~~table\n::33 1\n~~~</pre>`], '']);
     });
 
     it('data', () => {
@@ -483,8 +469,8 @@ describe('Unit: parser/block/extension/table', () => {
       assert.deepStrictEqual(
         inspect(parser([
           '~~~table',
-          `-\n#  1\n${[...Array(31)].map((_, i) => `: ${i + 2}`).join('\n')}`,
-          `-\n#! 1\n${[...Array(31)].map((_, i) => `: ${i + 2}`).join('\n')}`,
+          `-\n#  1\n${[...Array(32)].map((_, i) => `: ${i + 2}`).join('\n')}`,
+          `-\n#! 1\n${[...Array(32)].map((_, i) => `: ${i + 2}`).join('\n')}`,
           '~~~'
         ].join('\n'))),
         [[html('table', [
@@ -492,52 +478,52 @@ describe('Unit: parser/block/extension/table', () => {
           html('tbody', [
             html('tr', [
               html('th', '1'),
-              ...[...Array(31)].map((_, i) => html('td', `${i + 2}`)),
+              ...[...Array(32)].map((_, i) => html('td', `${i + 2}`)),
             ]),
             html('tr', [
               html('th', { class: 'highlight' }, '1'),
-              ...[...Array(31)].map((_, i) => html('td', { class: 'highlight', highlight: 'h' }, `${i + 2}`)),
+              ...[...Array(32)].map((_, i) => html('td', { class: 'highlight', highlight: 'h' }, `${i + 2}`)),
             ]),
           ]),
           html('tfoot')]).outerHTML], '']);
       assert.deepStrictEqual(
         inspect(parser([
           '~~~table',
-          `-\n${[...Array(31)].map((_, i) => `: ${i + 1}`).join('\n')}\n#  32`,
-          `-\n${[...Array(31)].map((_, i) => `: ${i + 1}`).join('\n')}\n#! 32`,
+          `-\n${[...Array(32)].map((_, i) => `: ${i + 1}`).join('\n')}\n#  33`,
+          `-\n${[...Array(32)].map((_, i) => `: ${i + 1}`).join('\n')}\n#! 33`,
           '~~~'
         ].join('\n'))),
         [[html('table', [
           html('thead'),
           html('tbody', [
             html('tr', [
-              ...[...Array(31)].map((_, i) => html('td', `${i + 1}`)),
-              html('th', '32'),
+              ...[...Array(32)].map((_, i) => html('td', `${i + 1}`)),
+              html('th', '33'),
             ]),
             html('tr', [
-              ...[...Array(31)].map((_, i) => html('td', { class: 'highlight', highlight: 'h' }, `${i + 1}`)),
-              html('th', { class: 'highlight' }, '32'),
+              ...[...Array(32)].map((_, i) => html('td', { class: 'highlight', highlight: 'h' }, `${i + 1}`)),
+              html('th', { class: 'highlight' }, '33'),
             ]),
           ]),
           html('tfoot')]).outerHTML], '']);
       assert.deepStrictEqual(
         inspect(parser([
           '~~~table',
-          `-\n${[...Array(31)].map((_, i) => `# ${i + 1}`).join('\n')}\n#! 32`,
-          `-\n${[...Array(32)].map((_, i) => `: ${i + 1}`).join('\n')}`,
+          `-\n${[...Array(32)].map((_, i) => `# ${i + 1}`).join('\n')}\n#! 33`,
+          `-\n${[...Array(33)].map((_, i) => `: ${i + 1}`).join('\n')}`,
           '~~~'
         ].join('\n'))),
         [[html('table', [
           html('thead', [
             html('tr', [
-              ...[...Array(31)].map((_, i) => html('th', `${i + 1}`)),
-              html('th', { class: 'highlight' }, '32'),
+              ...[...Array(32)].map((_, i) => html('th', `${i + 1}`)),
+              html('th', { class: 'highlight' }, '33'),
             ]),
           ]),
           html('tbody', [
             html('tr', [
-              ...[...Array(31)].map((_, i) => html('td', `${i + 1}`)),
-              html('td', { class: 'highlight', highlight: 'v' }, '32'),
+              ...[...Array(32)].map((_, i) => html('td', `${i + 1}`)),
+              html('td', { class: 'highlight', highlight: 'v' }, '33'),
             ]),
           ]),
           html('tfoot')]).outerHTML], '']);
@@ -668,6 +654,15 @@ describe('Unit: parser/block/extension/table', () => {
         ]).outerHTML], '']);
     });
 
+    it('type', () => {
+      assert.deepStrictEqual(
+        inspect(parser('~~~table/invalid\n~~~')),
+        [['<pre class="invalid" translate="no">~~~table/invalid\n~~~</pre>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser('~~~table/grid\n~~~')),
+        [[html('table', { 'data-type': 'grid' }).outerHTML], '']);
+    });
+
   });
 
 });

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

@@ -1,13 +1,13 @@
-import { undefined, Array } from 'spica/global';
+import { undefined, BigInt, Array } from 'spica/global';
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, block, line, validate, fence, rewrite, creator, open, clear, convert, trim, dup, recover, lazy, fmap } from '../../../combinator';
+import { union, subsequence, inits, some, block, line, validate, fence, rewrite, creator, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { localize } from '../../locale';
 import { visualize } from '../../util';
-import { html, defrag } from 'typed-dom/dom';
+import { html, define, defrag } from 'typed-dom/dom';
 import { unshift, splice } from 'spica/array';
 
 import TableParser = ExtensionParser.TableParser;
@@ -15,7 +15,7 @@ import RowParser = TableParser.RowParser;
 import AlignParser = TableParser.AlignParser;
 import CellParser = TableParser.CellParser;
 
-const opener = /^(~{3,})table(?!\S)([^\n]*)(?:$|\n)/;
+const opener = /^(~{3,})table(?:\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/;
 
 export const segment: TableParser.SegmentParser = block(validate('~~~',
   clear(fence(opener, 10000))));
@@ -23,10 +23,10 @@ export const segment: TableParser.SegmentParser = block(validate('~~~',
 export const segment_: TableParser.SegmentParser = block(validate('~~~',
   clear(fence(opener, 10000, false))), false);
 
-export const table: TableParser = block(validate('~~~', recover(fmap(
+export const table: TableParser = block(validate('~~~', fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], _, context) => {
+  ([body, overflow, closer, opener, delim, type, param]: string[], _, context) => {
     if (!closer || overflow || param.trimStart()) return [html('pre', {
       class: 'invalid',
       translate: 'no',
@@ -37,20 +37,21 @@ export const table: TableParser = block(validate('~~~', recover(fmap(
         overflow ?  `Invalid trailing line after the closing delimiter "${delim}"` :
         'Invalid argument',
     }, `${opener}${body}${overflow || closer}`)];
-    return eval(parser(body, context)) ?? [html('table')];
-  }),
-  (source, _, reason) =>
-    reason instanceof Error && reason.message === 'Number of columns must be 32 or less'
-      ? [[
-          html('pre', {
-            class: 'invalid',
-            translate: 'no',
-            'data-invalid-syntax': 'table',
-            'data-invalid-type': 'content',
-            'data-invalid-message': reason.message,
-          }, source),
-        ], '']
-      : (() => { throw reason; })())));
+    switch (type) {
+      case 'grid':
+      case undefined:
+        return (eval(parser(body, context)) ?? [html('table')])
+          .map(el => define(el, { 'data-type': type }));
+      default:
+        return [html('pre', {
+          class: 'invalid',
+          translate: 'no',
+          'data-invalid-syntax': 'table',
+          'data-invalid-type': 'argument',
+          'data-invalid-message': 'Invalid table type',
+        }, `${opener}${body}${closer}`)];
+    }
+  })));
 
 const parser: TableParser = lazy(() => block(localize(fmap(
   some(union([row])),
@@ -144,7 +145,7 @@ function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
   const valigns: ('middle' | 'top' | 'bottom' | '')[] = [];
   let target = thead;
   let ranges: Record<number, Record<number, HTMLTableCellElement>> = {};
-  let verticalHighlights = 0;
+  let verticalHighlights = 0n;
   ROW:
   for (let i = 0; i < rows.length; ++i) {
     // Copy to make them retryable.
@@ -214,25 +215,25 @@ function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
     }
     assert(valigns.length > 0);
     const row = html('tr');
-    let heads = 0;
-    let highlights = 0;
+    let heads = 0n;
+    let highlights = 0n;
     let hasDataCell = false;
-    let lHeadCellIdx: number;
-    let rHeadCellIdx: number;
-    for (let j = 0; j < cells.length && cells.length <= 32; ++j) {
+    let lHeadCellIdx: bigint;
+    let rHeadCellIdx: bigint;
+    for (let j = 0, jn = 0n; j < cells.length; jn = BigInt(++j)) {
       const isVirtual = !!ranges[i]?.[j];
       const cell = isVirtual
         ? splice(cells, j, 0, undefined) && ranges[i][j]
         : cells[j];
       const isHeadCell = cell.tagName === 'TH';
-      heads |= +isHeadCell << j;
-      highlights |= +!!cell.classList.contains('highlight') << j;
+      heads |= BigInt(isHeadCell) << jn;
+      highlights |= BigInt(cell.classList.contains('highlight')) << jn;
       hasDataCell ||= !isHeadCell;
       if (isHeadCell && !hasDataCell) {
-        lHeadCellIdx = j;
+        lHeadCellIdx = jn;
       }
       if (isHeadCell && hasDataCell) {
-        rHeadCellIdx ??= j;
+        rHeadCellIdx ??= jn;
       }
       const rowSpan = cell.rowSpan;
       assert(rowSpan > 0);
@@ -247,8 +248,8 @@ function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
       assert(colSpan > 0);
       if (colSpan > 1) {
         splice(cells, j + 1, 0, ...Array(colSpan - 1));
-        heads |= +`0b${`${heads & 1 << j && 1}`.repeat(colSpan)}` << j;
-        highlights |= +`0b${`${highlights & 1 << j && 1}`.repeat(colSpan)}` << j;
+        heads |= BigInt(+`0b${`${heads & 1n << jn && 1}`.repeat(colSpan)}`) << jn;
+        highlights |= BigInt(+`0b${`${highlights & 1n << jn && 1}`.repeat(colSpan)}`) << jn;
         j += colSpan - 1;
       }
       if (target === thead) {
@@ -282,20 +283,19 @@ function format(rows: Tree<RowParser>[]): HTMLTableSectionElement[] {
       aligns[j] && cell.setAttribute('align', aligns[j]);
       valigns[j] && cell.setAttribute('valign', valigns[j]);
     }
-    if (cells.length > 32) throw new Error('Number of columns must be 32 or less');
     target.appendChild(row);
     switch (target) {
       case thead:
         verticalHighlights = heads & highlights;
         continue;
       case tbody:
-        lHeadCellIdx ??= -1;
-        rHeadCellIdx ??= -1;
+        lHeadCellIdx ??= -1n;
+        rHeadCellIdx ??= -1n;
         const tHighlights = verticalHighlights;
         const horizontalHighlights = heads & highlights;
-        const lHighlight = ~lHeadCellIdx && horizontalHighlights & 1 << lHeadCellIdx;
-        const rHighlight = ~rHeadCellIdx && horizontalHighlights & 1 << rHeadCellIdx;
-        for (let i = 0, m = 1; i < cells.length; ++i, m <<= 1) {
+        const lHighlight = ~lHeadCellIdx && horizontalHighlights & 1n << lHeadCellIdx;
+        const rHighlight = ~rHeadCellIdx && horizontalHighlights & 1n << rHeadCellIdx;
+        for (let i = 0, m = 1n; i < cells.length; ++i, m <<= 1n) {
           const cell = cells[i];
           if (!cell) continue;
           if (heads & m) continue;

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

@@ -34,6 +34,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(word, word)')), [['(', 'word, word', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(A)')), [['(', 'A', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(Name)')), [['(', 'Name', ')'], '']);
+      assert.deepStrictEqual(inspect(parser('(Word word)')), [['<span class="paren">(Word word)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(Word Word)')), [['<span class="paren">(Word Word)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(Name, Name)')), [['(', 'Name, Name', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(ABBR)')), [['(', 'ABBR', ')'], '']);
@@ -43,6 +44,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('（０．１）')), [['（', '０．１', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（ａ）')), [['（', 'ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('（Ａ）')), [['（', 'Ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（Ａ，Ｂ）')), [['（', 'Ａ，Ｂ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('（Ａ、Ｂ）')), [['（', 'Ａ、Ｂ', '）'], '']);
     });
 
     it('[', () => {

package/src/parser/inline/bracket.ts

@@ -13,7 +13,7 @@ export const bracket: BracketParser = lazy(() => creator(union([
   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., ]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）')),
+  surround(str('（'), str(new RegExp(index.source.replace(', ', '[，、]').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/renderer/render/code.ts

@@ -1,4 +1,4 @@
-import * as Prism from 'prismjs';
+import Prism from 'prismjs';
 import { Collection } from 'spica/collection';
 
 export function code(target: HTMLElement, cache?: Collection<string, HTMLElement>): void {

package/src/renderer/render/media/twitter.ts

@@ -1,7 +1,7 @@
 import { window, document } from 'spica/global';
 import { parse } from '../../../parser';
 import { html as h, define } from 'typed-dom/dom';
-import { sanitize } from 'dompurify';
+import DOMPurify from 'dompurify';
 
 declare global {
   interface Window {
@@ -29,7 +29,7 @@ export function twitter(source: HTMLImageElement, url: URL): HTMLElement | undef
     timeout: 10 * 1e3,
     cache: true,
     success({ html }): void {
-      el.innerHTML = sanitize(html);
+      el.innerHTML = DOMPurify.sanitize(html);
       if (window.twttr) return void window.twttr.widgets.load(el);
       const id = 'twitter-wjs';
       if (document.getElementById(id)) return;

package/tsconfig.json

@@ -1,15 +1,16 @@
 {
   "compilerOptions": {
-    "target": "ES2019",
+    "target": "ES2021",
     "lib": [
-      "ES2019",
-      "ES2021.Promise",
+      "ES2021",
       "DOM",
       "DOM.Iterable"
     ],
+    "outDir": "dist",
     "module": "commonjs",
     "moduleResolution": "node",
     "esModuleInterop": true,
+    "sourceMap": true,
     "strict": true,
     "strictFunctionTypes": false,
     "noUnusedParameters": true,
@@ -19,13 +20,15 @@
     "suppressImplicitAnyIndexErrors": true,
     "noFallthroughCasesInSwitch": true,
     "noErrorTruncation": true,
-    "rootDir": "./",
-    "forceConsistentCasingInFileNames": true,
-    "removeComments": false
+    "forceConsistentCasingInFileNames": true
   },
   "include": [
     "*.ts",
     "src/**/*.ts",
-    "test/**/*.ts"
+    "test/**/*.ts",
+    "benchmark/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
   ]
 }