securemark 0.271.0 → 0.273.0

package/src/parser/processor/note.test.ts

@@ -0,0 +1,369 @@
+import { note, annotation, reference } from './note';
+import { parse as parse_ } from '../../parser';
+import { html } from 'typed-dom/dom';
+
+const parse = (s: string) => parse_(s, { test: true });
+
+describe('Unit: parser/processor/note', () => {
+  describe('annotation', () => {
+    it('empty', () => {
+      const target = parse('');
+      const note = html('ol');
+      [...annotation(target, note)];
+      assert.deepStrictEqual(
+        [...target.children].map(el => el.outerHTML),
+        []);
+      assert.deepStrictEqual(
+        note.outerHTML,
+        html('ol').outerHTML);
+    });
+
+    it('1', () => {
+      const target = parse('((a b))');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        assert.deepStrictEqual([...annotation(target, note)].length, i === 0 ? 2 : 1);
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:1', title: 'a b' }, [
+                html('span', { hidden: '' }, 'a b'),
+                html('a', { href: '#annotation::def:a_b' }, '*1')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'annotation::def:a_b' }, [
+              html('span', 'a b'),
+              html('sup', [html('a', { href: '#annotation::ref:1' }, '^1')]),
+            ]),
+          ]).outerHTML);
+      }
+    });
+
+    it('2', () => {
+      const target = parse('((1))((12345678901234567890))');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        assert.deepStrictEqual([...annotation(target, note)].length, i === 0 ? 4 : 2);
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:1', title: '1' }, [
+                html('span', { hidden: '' }, '1'),
+                html('a', { href: '#annotation::def:1' }, '*1')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:2', title: '12345678901234567890' }, [
+                html('span', { hidden: '' }, '12345678901234567890'),
+                html('a', { href: '#annotation::def:12345678901234567890' }, '*2')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'annotation::def:1' }, [
+              html('span', '1'),
+              html('sup', [html('a', { href: '#annotation::ref:1' }, '^1')]),
+            ]),
+            html('li', { id: 'annotation::def:12345678901234567890' }, [
+              html('span', '12345678901234567890'),
+              html('sup', [html('a', { href: '#annotation::ref:2' }, '^2')]),
+            ]),
+          ]).outerHTML);
+      }
+    });
+
+    it('unify', () => {
+      const target = parse('((1))((2))((3))((2))((4))');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        [...annotation(target, note)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:1', title: '1' }, [
+                html('span', { hidden: '' }, '1'),
+                html('a', { href: '#annotation::def:1' }, '*1')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:2', title: '2' }, [
+                html('span', { hidden: '' }, '2'),
+                html('a', { href: '#annotation::def:2' }, '*2')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:3', title: '3' }, [
+                html('span', { hidden: '' }, '3'),
+                html('a', { href: '#annotation::def:3' }, '*3')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:4', title: '2' }, [
+                html('span', { hidden: '' }, '2'),
+                html('a', { href: '#annotation::def:2' }, '*2')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:5', title: '4' }, [
+                html('span', { hidden: '' }, '4'),
+                html('a', { href: '#annotation::def:4' }, '*4')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'annotation::def:1' }, [
+              html('span', '1'),
+              html('sup', [html('a', { href: '#annotation::ref:1' }, '^1')]),
+            ]),
+            html('li', { id: 'annotation::def:2' }, [
+              html('span', '2'),
+              html('sup', [
+                html('a', { href: '#annotation::ref:2' }, '^2'),
+                html('a', { href: '#annotation::ref:4' }, '^4'),
+              ]),
+            ]),
+            html('li', { id: 'annotation::def:3' }, [
+              html('span', '3'),
+              html('sup', [html('a', { href: '#annotation::ref:3' }, '^3')]),
+            ]),
+            html('li', { id: 'annotation::def:4' }, [
+              html('span', '4'),
+              html('sup', [html('a', { href: '#annotation::ref:5' }, '^5')]),
+            ]),
+          ]).outerHTML);
+      }
+      [...annotation(parse(''), note)];
+      assert.deepStrictEqual(
+        note.outerHTML,
+        html('ol').outerHTML);
+    });
+
+    it('separation', () => {
+      const target = html('blockquote', parse([
+        '!>> ((1))\n> ((2))\n~~~',
+        '~~~~example/markdown\n((3))\n~~~~',
+        '((4))',
+      ].join('\n\n')).children);
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        [...annotation(target, note)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            '<blockquote><blockquote><section><p><sup class="annotation disabled" title="1"><span hidden="">1</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1"><span>1</span><sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote><section><p><sup class="annotation disabled" title="2"><span hidden="">2</span><a>*1</a></sup><br>~~~</p><ol class="annotations"><li data-marker="*1"><span>2</span><sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></blockquote>',
+            '<aside class="example" data-type="markdown"><pre translate="no">((3))</pre><hr><section><p><sup class="annotation disabled" title="3"><span hidden="">3</span><a>*1</a></sup></p><ol class="annotations"><li data-marker="*1"><span>3</span><sup><a>^1</a></sup></li></ol><h2>References</h2><ol class="references"></ol></section></aside>',
+            '<p><sup class="annotation" id="annotation::ref:1" title="4"><span hidden="">4</span><a href="#annotation::def:4">*1</a></sup></p>',
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          '<ol><li id="annotation::def:4"><span>4</span><sup><a href="#annotation::ref:1">^1</a></sup></li></ol>');
+      }
+    });
+
+    it('split', () => {
+      const target = parse('((1))\n\n## a\n\n## b\n\n((2))((3))\n\n## c\n\n((4))');
+      for (let i = 0; i < 3; ++i) {
+        [...note(target)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:1', title: '1' }, [
+                html('span', { hidden: '' }, '1'),
+                html('a', { href: '#annotation::def:1' }, '*1')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation::def:1', 'data-marker': '*1' }, [
+                html('span', '1'),
+                html('sup', [html('a', { href: '#annotation::ref:1' }, '^1')]),
+              ]),
+            ]).outerHTML,
+            html('h2', { id: 'index::a' }, 'a').outerHTML,
+            html('h2', { id: 'index::b' }, 'b').outerHTML,
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:2', title: '2' }, [
+                html('span', { hidden: '' }, '2'),
+                html('a', { href: '#annotation::def:2' }, '*2')
+              ]),
+              html('sup', { class: 'annotation', id: 'annotation::ref:3', title: '3' }, [
+                html('span', { hidden: '' }, '3'),
+                html('a', { href: '#annotation::def:3' }, '*3')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation::def:2', 'data-marker': '*2' }, [
+                html('span', '2'),
+                html('sup', [html('a', { href: '#annotation::ref:2' }, '^2')]),
+              ]),
+              html('li', { id: 'annotation::def:3', 'data-marker': '*3' }, [
+                html('span', '3'),
+                html('sup', [html('a', { href: '#annotation::ref:3' }, '^3')]),
+              ]),
+            ]).outerHTML,
+            html('h2', { id: 'index::c' }, 'c').outerHTML,
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:4', title: '4' }, [
+                html('span', { hidden: '' }, '4'),
+                html('a', { href: '#annotation::def:4' }, '*4')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation::def:4', 'data-marker': '*4' }, [
+                html('span', '4'),
+                html('sup', [html('a', { href: '#annotation::ref:4' }, '^4')]),
+              ]),
+            ]).outerHTML,
+          ]);
+      }
+    });
+
+    it('id', () => {
+      const target = parse('((a b))');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        assert.deepStrictEqual([...annotation(target, note, { id: '0' })].length, i === 0 ? 2 : 1);
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation:0:ref:1', title: 'a b' }, [
+                html('span', { hidden: '' }, 'a b'),
+                html('a', { href: '#annotation:0:def:a_b' }, '*1')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'annotation:0:def:a_b' }, [
+              html('span', 'a b'),
+              html('sup', [html('a', { href: '#annotation:0:ref:1' }, '^1')]),
+            ]),
+          ]).outerHTML);
+      }
+    });
+
+  });
+
+  describe('reference', () => {
+    it('1', () => {
+      const target = parse('[[a b]]');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        [...reference(target, note)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'reference', id: 'reference::ref:1', title: 'a b' }, [
+                html('span', { hidden: '' }, 'a b'),
+                html('a', { href: '#reference::def:a_b' }, '[1]')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'reference::def:a_b' }, [
+              html('span', 'a b'),
+              html('sup', [html('a', { href: '#reference::ref:1' }, '^1')]),
+            ]),
+          ]).outerHTML);
+      }
+    });
+
+    it('abbr', () => {
+      const target = parse('[[^a|b]][[^a]][[^a]]');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        [...reference(target, note)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'reference', 'data-abbr': 'a', id: 'reference::ref:1', title: 'b' }, [
+                html('span', { hidden: '' }, 'b'),
+                html('a', { href: '#reference::def:a' }, '[a]')
+              ]),
+              html('sup', { class: 'reference', 'data-abbr': 'a', id: 'reference::ref:2', title: 'b' }, [
+                html('span', { hidden: '' }),
+                html('a', { href: '#reference::def:a' }, '[a]')
+              ]),
+              html('sup', { class: 'reference', 'data-abbr': 'a', id: 'reference::ref:3', title: 'b' }, [
+                html('span', { hidden: '' }),
+                html('a', { href: '#reference::def:a' }, '[a]')
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'reference::def:a' }, [
+              html('span', 'b'),
+              html('sup', [
+                html('a', { href: '#reference::ref:1', title: 'b' }, '^1'),
+                html('a', { href: '#reference::ref:2' }, '^2'),
+                html('a', { href: '#reference::ref:3' }, '^3'),
+              ])
+            ]),
+          ]).outerHTML);
+      }
+    });
+
+    it('nest', () => {
+      const target = parse('((a[[^b]]))[[^b|c]]');
+      const note = html('ol');
+      for (let i = 0; i < 3; ++i) {
+        [...annotation(target)];
+        [...reference(target, note)];
+        assert.deepStrictEqual(
+          [...target.children].map(el => el.outerHTML),
+          [
+            html('p', [
+              html('sup', { class: 'annotation', id: 'annotation::ref:1', title: 'a' }, [
+                html('span', { hidden: '' }, [
+                  'a',
+                  html('sup', { class: 'reference', 'data-abbr': 'b' }, [
+                    html('span'),
+                  ]),
+                ]),
+                html('a', { href: '#annotation::def:a' }, '*1')
+              ]),
+              html('sup', { class: 'reference', 'data-abbr': 'b', id: 'reference::ref:1', title: 'c' }, [
+                html('span', { hidden: '' }, 'c'),
+                html('a', { href: '#reference::def:b' }, '[b]')
+              ]),
+            ]).outerHTML,
+            html('ol', { class: 'annotations' }, [
+              html('li', { id: 'annotation::def:a', 'data-marker': '*1' }, [
+                html('span', [
+                  'a',
+                  html('sup', { class: 'reference', 'data-abbr': 'b', id: 'reference::ref:2', title: 'c' }, [
+                    html('span', { hidden: '' }),
+                    html('a', { href: '#reference::def:b' }, '[b]')
+                  ]),
+                ]),
+                html('sup', [html('a', { href: '#annotation::ref:1' }, '^1')])
+              ]),
+            ]).outerHTML,
+          ]);
+        assert.deepStrictEqual(
+          note.outerHTML,
+          html('ol', [
+            html('li', { id: 'reference::def:b' }, [
+              html('span', 'c'),
+              html('sup', [
+                html('a', { href: '#reference::ref:1', title: 'c' }, '^1'),
+                html('a', { href: '#reference::ref:2' }, '^2'),
+              ]),
+            ]),
+          ]).outerHTML);
+        target.lastChild?.remove();
+      }
+    });
+
+  });
+
+});

package/src/parser/processor/{footnote.ts → note.ts}

@@ -1,9 +1,9 @@
 import { identity, text } from '../inline/extension/indexee';
 import { frag, html, define } from 'typed-dom/dom';
 
-export function* footnote(
+export function* note(
   target: ParentNode & Node,
-  footnotes?: { readonly annotations?: HTMLOListElement; readonly references: HTMLOListElement; },
+  notes?: { readonly annotations?: HTMLOListElement; readonly references: HTMLOListElement; },
   opts: { readonly id?: string; } = {},
   bottom: Node | null = null,
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
@@ -12,8 +12,8 @@ export function* footnote(
     const el = es[i];
     el.parentNode === target && el.remove();
   }
-  yield* reference(target, footnotes?.references, opts, bottom);
-  yield* annotation(target, footnotes?.annotations, opts, bottom);
+  yield* annotation(target, notes?.annotations, opts, bottom);
+  yield* reference(target, notes?.references, opts, bottom);
   return;
 }
 
@@ -30,7 +30,7 @@ function build(
   // 構文ごとに各1回の処理では不可能
   return function* (
     target: ParentNode & Node,
-    footnote?: HTMLOListElement,
+    note?: HTMLOListElement,
     opts: { readonly id?: string } = {},
     bottom: Node | null = null,
   ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
@@ -44,25 +44,16 @@ function build(
     }
     const refs = target.querySelectorAll(`sup.${syntax}:not(.disabled)`);
     const titles = new Map<string, string>();
-    const contents = new Map<string, HTMLSpanElement>();
-    for (let len = refs.length, i = 0; i < len; ++i) {
-      if (i % 10 === 9) yield;
-      const ref = refs[i];
-      const identifier = ref.getAttribute('data-abbr') || ` ${ref.firstElementChild!.innerHTML}`;
-      if (titles.has(identifier)) continue;
-      const content = html('span',
-        { id: identity(opts.id, text(ref.firstElementChild!), 'note') },
-        ref.firstElementChild!.cloneNode(true).childNodes);
-      const title = text(content).trim();
-      if (!title) continue;
-      titles.set(identifier, title);
-      contents.set(identifier, content);
-    }
+    const indexes = new Map<HTMLLIElement, number>();
     let count = 0;
     let total = 0;
     let style: 'count' | 'abbr';
     for (let len = refs.length, i = 0; i < len; ++i) {
       const ref = refs[i];
+      if (ref.closest('[hidden]')) {
+        yield;
+        continue;
+      }
       while (splitters.length > 0
           && splitters[0].compareDocumentPosition(ref) & Node.DOCUMENT_POSITION_FOLLOWING) {
         if (defs.size > 0) {
@@ -74,8 +65,13 @@ function build(
         }
         splitters.shift();
       }
-      const identifier = ref.getAttribute('data-abbr') || ` ${ref.firstElementChild!.innerHTML}`;
       const abbr = ref.getAttribute('data-abbr') || undefined;
+      const identifier = abbr || identity(undefined, text(ref.firstElementChild!), 'mark')?.slice(6) || '';
+      const title = undefined
+        || titles.get(identifier)
+        || titles.set(identifier, text(ref.firstElementChild!)).get(identifier)!
+        || null;
+      assert(syntax !== 'annotation' || title);
       style ??= abbr ? 'abbr' : 'count';
       if (style === 'count' ? abbr : !abbr) {
         define(ref, {
@@ -99,9 +95,6 @@ function build(
       else {
         ref.lastChild?.remove();
       }
-      const title = titles.get(identifier);
-      assert(title !== '');
-      assert(syntax !== 'annotation' || title);
       const refIndex = ++count;
       const refId = opts.id !== ''
         ? `${syntax}:${opts.id ?? ''}:ref:${refIndex}`
@@ -110,24 +103,26 @@ function build(
         || defs.get(identifier)
         || defs.set(identifier, html('li',
             {
-              id: opts.id !== '' ? `${syntax}:${opts.id ?? ''}:def:${total + defs.size + 1}` : undefined,
-              'data-marker': !footnote ? marker(total + defs.size + 1, abbr) : undefined,
+              id: opts.id !== '' ? `${syntax}:${opts.id ?? ''}:def:${identifier}` : undefined,
+              'data-marker': !note ? marker(total + defs.size + 1, abbr) : undefined,
             },
-            [contents.get(identifier) ?? frag(), html('sup')]))
+            [define(ref.firstElementChild!.cloneNode(true), { hidden: null }), html('sup')]))
             .get(identifier)!;
       assert(def.lastChild);
-      const defIndex = +def.id.slice(def.id.lastIndexOf(':') + 1) || total + defs.size;
+      const defIndex = undefined
+        || indexes.get(def)
+        || indexes.set(def, total + defs.size).get(def)!;
       const defId = def.id || undefined;
       define(ref, {
         id: refId,
-        class: opts.id !== '' ? undefined : `${ref.className} disabled`,
-        ...title
-          ? { title }
-          : { class: void ref.classList.add('invalid'),
-              'data-invalid-syntax': syntax,
-              'data-invalid-type': 'content',
-              'data-invalid-message': 'Missing the content',
-            },
+        class: opts.id !== '' ? undefined : void ref.classList.add('disabled'),
+        title,
+        ...!title && {
+          class: void ref.classList.add('invalid'),
+          'data-invalid-syntax': syntax,
+          'data-invalid-type': 'content',
+          'data-invalid-message': 'Missing the content',
+        },
       });
       yield ref.appendChild(html('a', { href: refId && defId && `#${defId}` }, marker(defIndex, abbr)));
       assert(ref.title || ref.matches('.invalid'));
@@ -139,14 +134,14 @@ function build(
           },
           `^${refIndex}`));
     }
-    if (defs.size > 0 || footnote) {
-      yield* proc(defs, footnote ?? target.insertBefore(html('ol', { class: `${syntax}s` }), splitters[0] ?? bottom));
+    if (defs.size > 0 || note) {
+      yield* proc(defs, note ?? target.insertBefore(html('ol', { class: `${syntax}s` }), splitters[0] ?? bottom));
     }
     return;
   }
 
-  function* proc(defs: Map<string, HTMLLIElement>, footnote: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
-    const { children } = footnote;
+  function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
+    const { children } = note;
     const size = defs.size;
     let count = 0;
     let length = children.length;
@@ -157,7 +152,7 @@ function build(
       while (length > size) {
         const node = children[count - 1] as HTMLLIElement;
         if (equal(node, def)) continue I;
-        yield footnote.removeChild(node);
+        yield note.removeChild(node);
         --length;
         assert(children.length === length);
       }
@@ -165,13 +160,13 @@ function build(
         ? children[count - 1]
         : null;
       if (node && equal(node, def)) continue;
-      assert(def.parentNode !== footnote);
-      yield footnote.insertBefore(def, node);
+      assert(def.parentNode !== note);
+      yield note.insertBefore(def, node);
       ++length;
       assert(children.length === length);
     }
     while (length > size) {
-      yield footnote.removeChild(children[size] as HTMLLIElement);
+      yield note.removeChild(children[size] as HTMLLIElement);
       --length;
       assert(children.length === length);
     }

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2021",
     "lib": [
-      "ES2021",
+      "ES2022",
       "DOM",
       "DOM.Iterable"
     ],
@@ -18,6 +18,7 @@
     "noImplicitOverride": true,
     "noPropertyAccessFromIndexSignature": true,
     "suppressImplicitAnyIndexErrors": true,
+    "ignoreDeprecations": "5.0",
     "noFallthroughCasesInSwitch": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true

package/webpack.config.js

@@ -33,7 +33,7 @@ module.exports = env => {
     resolve: {
       extensions: ['.ts', '.js'],
     },
-    entry: glob.sync('./{src,test}/**/*.ts'),
+    entry: glob.sync('./{src,test}/**/*.ts', { absolute: true }).sort(),
     output: {
       filename: 'index.js',
       path: path.resolve(__dirname, 'dist'),
@@ -81,7 +81,7 @@ module.exports = env => {
       return merge(config);
     case 'lint':
       return merge(config, {
-        entry: glob.sync('./!(node_modules)/**/*.ts'),
+        entry: glob.sync('./!(node_modules)/**/*.ts', { absolute: true }),
         plugins: [
           new ESLintPlugin({
             extensions: ['ts'],
@@ -90,7 +90,7 @@ module.exports = env => {
       });
     case 'bench':
       return merge(config, {
-        entry: glob.sync('./benchmark/**/*.ts'),
+        entry: glob.sync('./benchmark/**/*.ts', { absolute: true }).sort(),
         module: {
           rules: [
             {
@@ -109,7 +109,7 @@ module.exports = env => {
       });
     case 'dist':
       return merge(config, {
-        entry: glob.sync('./index.ts'),
+        entry: glob.sync('./index.ts', { absolute: true }),
         module: {
           rules: [
             {