securemark 0.263.0 → 0.264.0

package/src/parser/inline/mark.ts

@@ -1,19 +1,25 @@
 import { MarkParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
+import { identity, text } from './extension/indexee';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
 import { Syntax, State } from '../context';
 import { unshift } from 'spica/array';
-import { html, defrag } from 'typed-dom/dom';
+import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() => surround(
   str('==', '='),
+  constraint(State.mark, false,
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('==')),
-    open(some(inline, '='), mark),
-  ])))),
+    some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
+    open(some(inline, '=', [[/^\\?\n/, 9]]), mark),
+  ]))))),
   str('=='), false,
-  ([, bs], rest) => [[html('mark', defrag(bs))], rest],
+  ([, bs], rest, { id }) => {
+    const el = html('mark', defrag(bs));
+    define(el, { id: id !== '' && identity(text(el), 'mark') || undefined });
+    return [[el, html('a', { href: el.id ? `#${el.id}` : undefined })], rest];
+  },
   ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/media.ts

@@ -1,4 +1,3 @@
-import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
 import { union, inits, tails, some, syntax, creation, precedence, constraint, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { unsafelink, uri, option as linkoption, resolve } from './link';

package/src/parser/inline/reference.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
 import { union, subsequence, some, context, syntax, creation, constraint, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';

package/src/parser/inline/ruby.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
 import { sequence, syntax, creation, validate, verify, surround, lazy, fmap } from '../../combinator';

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

@@ -12,8 +12,10 @@ describe('Unit: parser/inline/strong', () => {
       assert.deepStrictEqual(inspect(parser('*a *')), [['*', 'a'], ' *']);
       assert.deepStrictEqual(inspect(parser('*a  *')), [['*', 'a', ' '], ' *']);
       assert.deepStrictEqual(inspect(parser('*a\n*')), [['*', 'a'], '\n*']);
+      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['*', 'a'], '\nb*']);
       assert.deepStrictEqual(inspect(parser('*a\\ *')), [['*', 'a'], '\\ *']);
       assert.deepStrictEqual(inspect(parser('*a\\\n*')), [['*', 'a'], '\\\n*']);
+      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['*', 'a'], '\\\nb*']);
       assert.deepStrictEqual(inspect(parser('* *')), undefined);
       assert.deepStrictEqual(inspect(parser('* a*')), undefined);
       assert.deepStrictEqual(inspect(parser('* a *')), undefined);
@@ -28,8 +30,6 @@ describe('Unit: parser/inline/strong', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('*a*')), [['<strong>a</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('*ab*')), [['<strong>ab</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\nb*')), [['<strong>a<br>b</strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('*a\\\nb*')), [['<strong>a<span class="linebreak"> </span>b</strong>'], '']);
     });
 
     it('nest', () => {

package/src/parser/inline/strong.ts

@@ -11,8 +11,8 @@ export const strong: StrongParser = lazy(() => surround(
   str('*', '*'),
   syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
-    some(inline, blankWith('*')),
-    open(some(inline, '*'), strong),
+    some(inline, blankWith('*'), [[/^\\?\n/, 9]]),
+    open(some(inline, '*', [[/^\\?\n/, 9]]), strong),
   ])))),
   str('*'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],

package/src/parser/inline/template.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
 import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';

package/src/parser/inline.test.ts

@@ -51,7 +51,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[]{{a}}')), [['[', ']', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{{a}}')), [['!', '[', ']', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('[\n]{a}')), [['[', '<br>', ']', '<a class="url" href="a">a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[\\\n]{a}')), [['[', '<span class="linebreak"> </span>', ']', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[\\\n]{a}')), [['[', '<br>', ']', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{}')), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a}')), [['<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('{{a}}')), [['<span class="template">{{a}}</span>'], '']);
@@ -81,6 +81,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[', '', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
@@ -89,11 +90,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<strong>b<br>c</strong>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<strong>a<br>b</strong>', ']', '<a class="url" href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
-      assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<strong>a<br>b</strong>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a++b\nc++]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<ins>b<br>c</ins>', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[++a\nb++]{/}')), [['[', '<ins>a<br>b</ins>', ']', '<a class="url" href="/">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[++a\nb]++')), [['[', '++', 'a', '<br>', 'b', ']', '++'], '']);
+      assert.deepStrictEqual(inspect(parser('[++[a\nb++]')), [['', '[', '++', '[', 'a', '<br>', 'b', '++', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[++a\nb++]]')), [['[', '[', '<ins>a<br>b</ins>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });
@@ -158,7 +159,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('0aあい#b')), [['0a', 'あ', 'い#b'], '']);
       assert.deepStrictEqual(inspect(parser('「#あ」')), [['「', '<a class="hashtag" href="/hashtags/あ">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<span class="linebreak"> </span>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_a_#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<strong>a</strong>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);

package/src/parser/processor/figure.ts

@@ -1,4 +1,3 @@
-import { Infinity, Set, Map } from 'spica/global';
 import { number as calculate, isFixed } from '../inline/extension/label';
 import { MultiQueue } from 'spica/queue';
 import { push } from 'spica/array';

package/src/parser/processor/footnote.ts

@@ -1,4 +1,3 @@
-import { undefined, Infinity, Map, Node } from 'spica/global';
 import { text } from '../inline/extension/indexee';
 import { MultiQueue } from 'spica/queue';
 import { frag, html, define } from 'typed-dom/dom';

package/src/parser/segment.ts

@@ -1,4 +1,3 @@
-import { Blob } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
 import { eval, exec } from '../combinator/data/parser';
 import { union, some } from '../combinator';

package/src/parser/source/escapable.test.ts

@@ -39,7 +39,7 @@ describe('Unit: parser/source/escsource', () => {
       assert.deepStrictEqual(inspect(parser('\\a')), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\$')), [['\\$'], '']);
       assert.deepStrictEqual(inspect(parser('\\　')), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\\n'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '\n'], '']);
     });
 
   });

package/src/parser/source/escapable.ts

@@ -15,7 +15,13 @@ export const escsource: EscapableSourceParser = creation(1, false, ({ source })
         case '\x1B':
           return [[source.slice(1, 2)], source.slice(2)];
         case '\\':
-          return [[source.slice(0, 2)], source.slice(2)];
+          switch (source[1]) {
+            case undefined:
+            case '\n':
+              return [[source[0]], source.slice(1)];
+            default:
+              return [[source.slice(0, 2)], source.slice(2)];
+          }
         default:
           const b = source[0] !== '\n' && source[0].trimStart() === '';
           const i = b

package/src/parser/source/line.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
 import { line, isEmpty } from '../../combinator';
 

package/src/parser/source/str.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';

package/src/parser/source/text.test.ts

@@ -18,14 +18,28 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a\nb')), [['a', '<br>', 'b'], '']);
     });
 
+    it('escape', () => {
+      assert.deepStrictEqual(inspect(parser('\\')), [[], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\\\')), [['\\', '\\'], '']);
+      assert.deepStrictEqual(inspect(parser('\\ ')), [[' '], '']);
+      assert.deepStrictEqual(inspect(parser('\\_')), [['_'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0')), [['0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\a')), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\　')), [['　'], '']);
+      assert.deepStrictEqual(inspect(parser('\\。')), [['。'], '']);
+    });
+
     it('space', () => {
       assert.deepStrictEqual(inspect(parser(' ')), [[], '']);
       assert.deepStrictEqual(inspect(parser('  ')), [[], '']);
       assert.deepStrictEqual(inspect(parser('   ')), [[], '']);
       assert.deepStrictEqual(inspect(parser(' \n')), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser('  \n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n')), [['<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser(' \\\n')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \\\n')), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser(' a')), [[' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('  a')), [[' ', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('   a')), [['  ', ' ', 'a'], '']);
@@ -33,8 +47,8 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('a  ')), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('a \n')), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a  \n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a b')), [['a', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('a  b')), [['a', ' ', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('a   b')), [['a', '  ', ' ', 'b'], '']);
@@ -51,27 +65,13 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('。\n')), [['。', '<br>'], '']);
     });
 
-    it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\\')), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_')), [['_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0')), [['0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\a')), [['\\', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　')), [['　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\。')), [['。'], '']);
-    });
-
     it('softbreak', () => {
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n ')), [['<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\na')), [['<span class="linebreak"> </span>', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n')), [['a', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n')), [['a', '<span class="linebreak"> </span>', 'b', '<span class="linebreak"> </span>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\n')), [['\\', '<span class="linebreak"> </span>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n ')), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\na')), [['<br>', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\n')), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n')), [['a', '<br>', 'b', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\\n')), [['\\', '<br>'], '']);
     });
 
     it('account', () => {
@@ -116,17 +116,6 @@ describe('Unit: parser/text/text', () => {
       assert.deepStrictEqual(inspect(parser('>>>>0')), [['>', '>', '>', '>', '0'], '']);
     });
 
-    it('localize', () => {
-      assert.deepStrictEqual(inspect(parser('a\\\n0')), [['a', '<span class="linebreak"> </span>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('ア\\\n０')), [['ア', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('亜\\\n０')), [['亜', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('、\\\n０')), [['、', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('。\\\n０')), [['。', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('！？\\\n０')), [['！', '？', '<span class="linebreak"></span>', '０'], '']);
-      assert.deepStrictEqual(inspect(parser('\\あ\\\n０')), [['あ', '<span class="linebreak"></span>', '０'], '']);
-    });
-
   });
 
 });

package/src/parser/source/text.ts

@@ -1,13 +1,11 @@
-import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S[#>]|[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
+export const delimiter = /[\s\x00-\x7F]|\S[#>]/u;
 export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
-const nssb = /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？][^\S\n]*(?=\\\n)/u;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creation(1, false, ({ source, context }) => {
@@ -17,26 +15,14 @@ export const text: TextParser = creation(1, false, ({ source, context }) => {
     case -1:
       return [[source], ''];
     case 0:
-      switch (source[0]) {
-        case '\x1B':
-        case '\\':
-          if (!nssb.test(source.slice(1))) break;
-          assert(source[0] !== '\x1B');
-          return text({ source: source.slice(1), context });
-        default:
-          const i = source.match(nssb)?.[0].length ?? -1;
-          if (i !== -1) return [[source[0], html('span', { class: 'linebreak' })], source.slice(i + 2)];
-      }
       switch (source[0]) {
         case '\x1B':
         case '\\':
           switch (source[1]) {
             case undefined:
-              assert(source[0] !== '\x1B');
-              return [[], ''];
             case '\n':
               assert(source[0] !== '\x1B');
-              return [[html('span', { class: 'linebreak' }, ' ')], source.slice(2)];
+              return [[], source.slice(1)];
             default:
               return [[source.slice(1, 2)], source.slice(2)];
           }

package/src/parser/visibility.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
 import { Parser, Input, eval } from '../combinator/data/parser';
 import { union, some, verify, convert, fmap } from '../combinator';
@@ -109,10 +108,7 @@ export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boo
   for (let i = 0; i < nodes.length; ++i) {
     const node = nodes[i];
     if (isVisible(node)) return true;
-    if (typeof node === 'object') {
-      if (node.tagName === 'BR') break;
-      if (node.className === 'linebreak') break;
-    }
+    if (typeof node === 'object' && node.tagName === 'BR') break;
   }
   return false;
 }
@@ -144,8 +140,6 @@ function isVisible(node: HTMLElement | string, strpos?: number): boolean {
         case 'BR':
         case 'WBR':
           return false;
-        case 'SPAN':
-          return node.className !== 'linebreak';
         default:
           return true;
       }

package/src/renderer/render/math.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { Dict } from 'spica/dict';
 import { html, define } from 'typed-dom/dom';
 

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

@@ -1,4 +1,3 @@
-import { Object } from 'spica/global';
 import { Dict } from 'spica/dict';
 import { define } from 'typed-dom/dom';
 

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

@@ -1,4 +1,3 @@
-import { window, document } from 'spica/global';
 import { parse } from '../../../parser';
 import { html as h, define } from 'typed-dom/dom';
 import DOMPurify from 'dompurify';

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

@@ -1,4 +1,3 @@
-import { undefined, Object } from 'spica/global';
 import { html } from 'typed-dom/dom';
 
 const extensions = [

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

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { html } from 'typed-dom/dom';
 
 export function youtube(source: HTMLImageElement, url: URL): HTMLElement | undefined {

package/src/renderer/render.ts

@@ -1,4 +1,3 @@
-import { location } from 'spica/global';
 import { RenderingOptions } from '../../';
 import { code } from './render/code';
 import { math } from './render/math';

package/src/util/quote.ts

@@ -1,4 +1,3 @@
-import { Element } from 'spica/global';
 import { exec } from '../combinator/data/parser';
 import { cite } from '../parser/block/reply/cite';
 import { define } from 'typed-dom/dom';

package/src/util/scope.ts

@@ -1,5 +1,3 @@
-import { undefined, WeakMap } from 'spica/global';
-
 export function scope(
   base: DocumentFragment | HTMLElement | ShadowRoot,
   filter: string = '',

package/src/util/toc.ts

@@ -1,4 +1,3 @@
-import { undefined } from 'spica/global';
 import { push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 

package/webpack.config.js

@@ -6,7 +6,7 @@ const { mergeWithRules } = require('webpack-merge');
 const ESLintPlugin = require('eslint-webpack-plugin');
 const pkg = require('./package.json');
 
-shell('rm -rf coverage');
+shell('rm -rf dist coverage');
 
 module.exports = env => {
   const merge = mergeWithRules({

package/src/parser/locale/ja.test.ts

@@ -1,14 +0,0 @@
-import { japanese } from './ja';
-
-describe('Unit: parser/locale/ja', () => {
-  describe('japanese', () => {
-    it('ja', () => {
-      assert(japanese('、'));
-      assert(japanese('。'));
-      assert(japanese('！'));
-      assert(japanese('？'));
-    });
-
-  });
-
-});

package/src/parser/locale/ja.ts

@@ -1,3 +0,0 @@
-export function japanese(char: string): boolean {
-  return /^[\p{Ideo}\p{scx=Hiragana}\p{scx=Katakana}～！？]/u.test(char);
-}

package/src/parser/locale.test.ts

@@ -1,26 +0,0 @@
-import { block } from './block';
-import { some } from '../combinator';
-import { inspect } from '../debug.test';
-
-describe('Unit: parser/locale', () => {
-  describe('locale', () => {
-    const parser = (source: string) => some(block)({ source, context: {} });
-
-    it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('。 \\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('_。_\\\n0')), [['<p><em>。</em><span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('!> 。\\\n0')), [['<blockquote><section><p>。<span class="linebreak"></span>0</p><h2>References</h2><ol class="references"></ol></section></blockquote>'], '']);
-      assert.deepStrictEqual(inspect(parser('[。](a)\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('[。　](a )\\\n0')), [['<p><ruby>。<rp>(</rp><rt>a</rt><rp>)</rp></ruby><span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('。<wbr>\\\n0')), [['<p>。<wbr><span class="linebreak"></span>0</p>'], '']);
-    });
-
-    it('ja', () => {
-      assert.deepStrictEqual(inspect(parser('。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\。\\\n0')), [['<p>。<span class="linebreak"></span>0</p>'], '']);
-    });
-
-  });
-
-});

package/src/parser/locale.ts

@@ -1,61 +0,0 @@
-import { Parser } from '../combinator/data/parser';
-import { fmap } from '../combinator';
-import { japanese } from './locale/ja';
-import { html } from 'typed-dom/dom';
-
-export function localize<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLElement | string> {
-  return fmap(parser, ns => {
-    if (ns.length === 0) return ns;
-    const el = ns.length === 1 && typeof ns[0] === 'object'
-      ? ns[0]
-      : html('div', ns);
-    for (let es = el.querySelectorAll('.linebreak:not(:empty)'),
-             len = es.length, i = 0; i < len; ++i) {
-      const el = es[i];
-      assert(el.firstChild!.textContent === ' ');
-      if (!check(el)) continue;
-      el.firstChild!.remove();
-    }
-    return ns;
-  });
-}
-
-function check(el: Element): boolean {
-  const char = lastChar(el);
-  if (!char) return false;
-  assert([...char].length === 1);
-  return japanese(char);
-}
-
-function lastChar(node: Element | Text | null): string {
-  while (node = node?.previousSibling as typeof node) {
-    if (!('id' in node)) return [...node.data.slice(-2)].pop() ?? '';
-    if (node.firstChild) return [...text(node).slice(-2)].pop() ?? '';
-    switch (node.tagName) {
-      case 'BR':
-        return '';
-      case 'SPAN':
-        switch (node.className) {
-          case 'linebreak':
-            return '';
-        }
-    }
-  }
-  return '';
-}
-
-function text(el: Element): string {
-  switch (el.tagName) {
-    case 'RUBY':
-      for (let ns = el.childNodes, i = ns.length; i--;) {
-        const child = ns[i] as Text | Element;
-        if ('id' in child) continue;
-        return child.data;
-      }
-      assert(false);
-      return '';
-    default:
-      return el.textContent!;
-  }
-}