securemark 0.244.2 → 0.247.0

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

@@ -12,21 +12,24 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$$')), undefined);
       assert.deepStrictEqual(inspect(parser('$$$')), undefined);
       assert.deepStrictEqual(inspect(parser('$0 $')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0.$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$1,000.99.$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0(a)$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0[a]$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0{a}$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0 -$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0 - $')), undefined);
-      assert.deepStrictEqual(inspect(parser('$0 + $')), undefined);
-      assert.deepStrictEqual(inspect(parser('$-0$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$-0$-1')), undefined);
-      assert.deepStrictEqual(inspect(parser('$-a$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$-a$-b')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-0, $-1')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-0 and $-1')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-0と$-1')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a $-b')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a\\ $-b')), undefined);
       assert.deepStrictEqual(inspect(parser('$a $')), undefined);
-      assert.deepStrictEqual(inspect(parser('$a-b$')), undefined);
-      assert.deepStrictEqual(inspect(parser('$a-b$c-d')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a"$-b"')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a\\"$-b\\"')), undefined);
+      assert.deepStrictEqual(inspect(parser('$a"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a($-b)')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a\\($-b\\)')), undefined);
+      assert.deepStrictEqual(inspect(parser('$a($')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a[$-b]')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a\\[$-b\\]')), undefined);
+      assert.deepStrictEqual(inspect(parser('$a[$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a{$-b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('$-a\\{$-b\\}')), undefined);
+      assert.deepStrictEqual(inspect(parser('$a{$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b')), undefined);
       assert.deepStrictEqual(inspect(parser('$a$b$')), undefined);
       assert.deepStrictEqual(inspect(parser('$ $')), undefined);
@@ -35,35 +38,46 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('$\n$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\\$\nb$')), undefined);
       assert.deepStrictEqual(inspect(parser('$a\\$\\\nb$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$`"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a"$0')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a""$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$```a""$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``\n"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a\\$\nb"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$``a\\$\\\nb"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$"$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${')), undefined);
       assert.deepStrictEqual(inspect(parser('${a')), undefined);
       assert.deepStrictEqual(inspect(parser('${$')), undefined);
       assert.deepStrictEqual(inspect(parser('${}')), undefined);
       assert.deepStrictEqual(inspect(parser('${a} $')), undefined);
-      assert.deepStrictEqual(inspect(parser('${a}b$')), undefined);
-      assert.deepStrictEqual(inspect(parser('${a}{b}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${a{b}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${a}b}$')), undefined);
+      assert.deepStrictEqual(inspect(parser('${$}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${\\}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${\n}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${a\\$\nb}$')), undefined);
       assert.deepStrictEqual(inspect(parser('${a\\$\\\nb}$')), undefined);
+      assert.deepStrictEqual(inspect(parser('$\\begin{}$')), [['<span class="invalid" translate="no">$\\begin{}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\huge{}$')), [['<span class="invalid" translate="no">$\\huge{}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$\\Begin{}$')), [['<span class="invalid" translate="no">$\\Begin{}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\begin}$')), [['<span class="invalid" translate="no">${\\begin}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${\\Huge}$')), [['<span class="invalid" translate="no">${\\Huge}$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${a}b$')), undefined);
       assert.deepStrictEqual(inspect(parser(' ${a}$')), undefined);
     });
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('$0$')), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$0$$')), [['<span class="math" translate="no" data-src="$0$">$0$</span>'], '$']);
+      assert.deepStrictEqual(inspect(parser('$00$')), [['<span class="math" translate="no" data-src="$00$">$00$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$-0$')), [['<span class="math" translate="no" data-src="$-0$">$-0$</span>'], '']);
       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('$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('$a$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a$$')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '$']);
-      assert.deepStrictEqual(inspect(parser('$a -b$')), [['<span class="math" translate="no" data-src="$a -b$">$a -b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$a-b$')), [['<span class="math" translate="no" data-src="$a-b$">$a-b$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a+b$')), [['<span class="math" translate="no" data-src="$a+b$">$a+b$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a*b$')), [['<span class="math" translate="no" data-src="$a*b$">$a*b$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$a/b$')), [['<span class="math" translate="no" data-src="$a/b$">$a/b$</span>'], '']);
@@ -71,6 +85,7 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser(`$a''$`)), [[`<span class="math" translate="no" data-src="$a''$">$a''$</span>`], '']);
       assert.deepStrictEqual(inspect(parser('$a$[A](a)')), [['<span class="math" translate="no" data-src="$a$">$a$</span>'], '[A](a)']);
       assert.deepStrictEqual(inspect(parser('$A$')), [['<span class="math" translate="no" data-src="$A$">$A$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$-a$')), [['<span class="math" translate="no" data-src="$-a$">$-a$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\$$')), [['<span class="math" translate="no" data-src="$\\$$">$\\$$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\Pi$')), [['<span class="math" translate="no" data-src="$\\Pi$">$\\Pi$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('$\\ 0$')), [['<span class="math" translate="no" data-src="$\\ 0$">$\\ 0$</span>'], '']);
@@ -86,6 +101,18 @@ describe('Unit: parser/inline/math', () => {
       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>'], '']);
       assert.deepStrictEqual(inspect(parser('$k$-space')), [['<span class="math" translate="no" data-src="$k$">$k$</span>'], '-space']);
+      assert.deepStrictEqual(inspect(parser('$`$')), [['<span class="math" translate="no" data-src="$`$">$`$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$`"a$')), [['<span class="math" translate="no" data-src="$`&quot;a$">$`"a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``$')), [['<span class="math" translate="no" data-src="$``$">$``$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``"$')), [['<span class="math" translate="no" data-src="$``&quot;$">$``"$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``""a$')), [['<span class="math" translate="no" data-src="$``&quot;&quot;a$">$``""a$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``a"$')), [['<span class="math" translate="no" data-src="$``a&quot;$">$``a"$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``$"$')), [['<span class="math" translate="no" data-src="$``$">$``$</span>'], '"$']);
+      assert.deepStrictEqual(inspect(parser('$``\\"$')), [['<span class="math" translate="no" data-src="$``\\&quot;$">$``\\"$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$``a``b"c"$')), [['<span class="math" translate="no" data-src="$``a``b&quot;c&quot;$">$``a``b"c"$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$```"$')), [['<span class="math" translate="no" data-src="$```&quot;$">$```"$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$````""$')), [['<span class="math" translate="no" data-src="$````&quot;&quot;$">$````""$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('$a{b}$')), [['<span class="math" translate="no" data-src="$a{b}$">$a{b}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${}$')), [['<span class="math" translate="no" data-src="${}$">${}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ }$')), [['<span class="math" translate="no" data-src="${ }$">${ }$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${a}$')), [['<span class="math" translate="no" data-src="${a}$">${a}$</span>'], '']);
@@ -97,10 +124,14 @@ describe('Unit: parser/inline/math', () => {
       assert.deepStrictEqual(inspect(parser('${a }$')), [['<span class="math" translate="no" data-src="${a }$">${a }$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ a}$')), [['<span class="math" translate="no" data-src="${ a}$">${ a}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${ a }$')), [['<span class="math" translate="no" data-src="${ a }$">${ a }$</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('${$}$')), [['<span class="math" translate="no" data-src="${$}$">${$}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${``a"}$')), [['<span class="math" translate="no" data-src="${``a&quot;}$">${``a"}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\a}$')), [['<span class="math" translate="no" data-src="${\\a}$">${\\a}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\$}$')), [['<span class="math" translate="no" data-src="${\\$}$">${\\$}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${\\\\}$')), [['<span class="math" translate="no" data-src="${\\\\}$">${\\\\}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${a}b$')), [['<span class="math" translate="no" data-src="${a}b$">${a}b$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${a}b{c}$')), [['<span class="math" translate="no" data-src="${a}b{c}$">${a}b{c}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${a}{b}$')), [['<span class="math" translate="no" data-src="${a}{b}$">${a}{b}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('${あ}$')), [['<span class="math" translate="no" data-src="${あ}$">${あ}$</span>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/math.ts

@@ -1,35 +1,34 @@
 import { MathParser } from '../inline';
-import { union, some, validate, rewrite, creator, surround, lazy } from '../../combinator';
+import { union, some, validate, focus, rewrite, creator, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { html } from 'typed-dom/dom';
 
-const disallowedCommand = /\\(?:begin|tiny|huge|large)(?![0-9a-z])/i;
+const syntax = /^(?:[ "([](?!\$)|\\{(?!\$)|\\[\\}$]?|^`|`(?!`)|[!#%&')\x2A-\x5A\]^_\x61-\x7A|~])+/;
+const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![0-9a-z])/i;
 
 export const math: MathParser = lazy(() => creator(validate('$', rewrite(
   union([
-    surround(
-      '$',
-      // Latex's reserved characters: # $ % ^ & _ { } ~ \
-      // $[0-9]+                    : Dollar
-      // $[A-z]*-                   : Label
-      // $[A-z]*(?!-)               : Math
-      // $[\^_[({|]                 : Math
-      // $[#$%&]                    : Invalid first character in Latex syntax
-      str(/^(?![\s{}#$%&]|\d+(?:[,.]\d+)*[^-+*/=<>^_~\\$]|-[\da-z]|[a-z]+-)(?:\\\$|\x20(?!\$)|[\x21-\x23\x25-\x7E])+/i),
-      /^\$(?![0-9a-z])/i),
     surround('$', bracket, '$'),
+    surround(
+      /^\$(?!\s)/,
+      some(union([
+        bracket,
+        quote,
+        str(syntax),
+      ])),
+      /^\$(?![0-9A-Za-z])/),
   ]),
   (source, { caches: { math: cache } = {} }) => [[
     cache?.get(source)?.cloneNode(true) ||
     html('span',
-      !disallowedCommand.test(source)
+      !forbiddenCommand.test(source)
         ? { class: 'math', translate: 'no', 'data-src': source }
         : {
             class: 'invalid',
             translate: 'no',
             'data-invalid-syntax': 'math',
             'data-invalid-type': 'content',
-            'data-invalid-message': `"${source.match(disallowedCommand)![0]}" command is disallowed`,
+            'data-invalid-message': `"${source.match(forbiddenCommand)![0]}" command is disallowed`,
           },
       source)
   ], '']))));
@@ -38,7 +37,17 @@ const bracket: MathParser.BracketParser = lazy(() => creator(surround(
   '{',
   some(union([
     bracket,
-    some(escsource, /^(?:[{}]|\\?\n)/),
+    some(escsource, /^(?:[{}$]|\\?\n)/),
   ])),
   '}',
   true)));
+
+const quote: MathParser.QuoteParser = lazy(() => creator(surround(
+  '``',
+  some(union([
+    quote,
+    bracket,
+    focus(/^(?:\\[\\{}$]|`(?!`)|[^`{}"$\n])*/, str(syntax)),
+  ])),
+  /^"?/,
+  true)));

package/src/parser/inline.test.ts

@@ -112,7 +112,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[$1]')), [['[', '$', '1', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$1-2]')), [['[', '$', '1', '-', '2', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$-1][$-2]')), [['<a class="label" data-label="$-1">$-1</a>', '<a class="label" data-label="$-2">$-2</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('$-1$-2')), [['<a class="label" data-label="$-1">$-1</a>', '<a class="label" data-label="$-2">$-2</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('$-1, $-2')), [['<a class="label" data-label="$-1">$-1</a>', ',', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('$-1 and $-2')), [['<a class="label" data-label="$-1">$-1</a>', ' ', 'and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$$-1')), [['$', '<a class="label" data-label="$-1">$-1</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#a]]')), [['<sup class="reference"><a href="/hashtags/a" class="hashtag">#a</a></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[$-1]]')), [['<sup class="reference"><a class="label" data-label="$-1">$-1</a></sup>'], '']);

package/src/parser/inline.ts

@@ -5,6 +5,7 @@ import { annotation } from './inline/annotation';
 import { reference } from './inline/reference';
 import { template } from './inline/template';
 import { comment } from './inline/comment';
+import { math } from './inline/math';
 import { extension } from './inline/extension';
 import { ruby } from './inline/ruby';
 import { link } from './inline/link';
@@ -16,7 +17,6 @@ import { emstrong } from './inline/emstrong';
 import { emphasis } from './inline/emphasis';
 import { strong } from './inline/strong';
 import { code } from './inline/code';
-import { math } from './inline/math';
 import { media } from './inline/media';
 import { htmlentity } from './inline/htmlentity';
 import { shortmedia } from './inline/shortmedia';
@@ -30,6 +30,7 @@ export import AnnotationParser = InlineParser.AnnotationParser;
 export import ReferenceParser = InlineParser.ReferenceParser;
 export import TemplateParser = InlineParser.TemplateParser;
 export import CommentParser = InlineParser.CommentParser;
+export import MathParser = InlineParser.MathParser;
 export import ExtensionParser = InlineParser.ExtensionParser;
 export import RubyParser = InlineParser.RubyParser;
 export import LinkParser = InlineParser.LinkParser;
@@ -41,7 +42,6 @@ export import EmStrongParser = InlineParser.EmStrongParser;
 export import EmphasisParser = InlineParser.EmphasisParser;
 export import StrongParser = InlineParser.StrongParser;
 export import CodeParser = InlineParser.CodeParser;
-export import MathParser = InlineParser.MathParser;
 export import MediaParser = InlineParser.MediaParser;
 export import HTMLEntityParser = InlineParser.HTMLEntityParser;
 export import UnsafeHTMLEntityParser = InlineParser.UnsafeHTMLEntityParser;
@@ -55,6 +55,7 @@ export const inline: InlineParser = union([
   reference,
   template,
   comment,
+  math,
   extension,
   ruby,
   link,
@@ -67,7 +68,6 @@ export const inline: InlineParser = union([
   strong,
   emphasis,
   code,
-  math,
   htmlentity,
   shortmedia,
   autolink,

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"
   ]
 }

package/webpack.config.js

@@ -0,0 +1,129 @@
+const path = require('path');
+const glob = require('glob');
+const shell = cmd => require('child_process').execSync(cmd, { stdio: [0, 1, 2] });
+const webpack = require('webpack');
+const { mergeWithRules } = require('webpack-merge');
+const ESLintPlugin = require('eslint-webpack-plugin');
+const pkg = require('./package.json');
+
+shell('rm -rf coverage');
+
+module.exports = env => {
+  const merge = mergeWithRules({
+    entry: 'replace',
+    module: {
+      rules: {
+        test: 'match',
+        use: {
+          loader: 'match',
+          options: 'replace',
+          plugins: 'replace',
+        },
+      },
+    },
+    plugins: 'append',
+  });
+  const config = {
+    mode: 'production',
+    externals: {
+      benchmark: 'Benchmark',
+      prismjs: 'Prism',
+      dompurify: 'DOMPurify',
+    },
+    resolve: {
+      extensions: ['.ts', '.js'],
+    },
+    entry: glob.sync('./{src,test}/**/*.ts'),
+    output: {
+      filename: 'index.js',
+      path: path.resolve(__dirname, 'dist'),
+      library: pkg.name,
+      libraryTarget: 'umd',
+      globalObject: 'this',
+      clean: true,
+    },
+    module: {
+      rules: [
+        {
+          test: /\.ts$/,
+          //exclude: /node_modules/,
+          use: [
+            {
+              loader: 'babel-loader',
+              options: {},
+            },
+            {
+              loader: 'ts-loader',
+              options: {
+                onlyCompileBundledFiles: true,
+              },
+            },
+          ],
+        },
+      ],
+    },
+    plugins: [
+      new webpack.BannerPlugin({
+        banner: `${pkg.name} v${pkg.version} ${pkg.repository.url} | (c) 2017, ${pkg.author} | ${pkg.license} License`,
+      }),
+    ],
+    performance: {
+      maxEntrypointSize: Infinity,
+      maxAssetSize: Infinity,
+    },
+    optimization: {
+      minimize: false,
+    },
+  };
+  switch (env.mode) {
+    case 'test':
+      return merge(config);
+    case 'lint':
+      return merge(config, {
+        entry: glob.sync('./!(node_modules)**/*.ts'),
+        plugins: [
+          new ESLintPlugin({
+            extensions: ['ts'],
+          }),
+        ],
+      });
+    case 'bench':
+      return merge(config, {
+        entry: glob.sync('./benchmark/**/*.ts'),
+        module: {
+          rules: [
+            {
+              test: /\.ts$/,
+              use: [
+                {
+                  loader: 'babel-loader',
+                  options: {
+                    plugins: ['babel-plugin-unassert'],
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      });
+    case 'dist':
+      return merge(config, {
+        entry: glob.sync('./index.ts'),
+        module: {
+          rules: [
+            {
+              test: /\.ts$/,
+              use: [
+                {
+                  loader: 'babel-loader',
+                  options: {
+                    plugins: ['babel-plugin-unassert'],
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      });
+  }
+};