securemark 0.258.0 → 0.258.3

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

@@ -22,6 +22,7 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]')), undefined);
       assert.deepStrictEqual(inspect(parser('!{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('![{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ }')), undefined);

package/src/parser/inline/media.ts

@@ -1,11 +1,11 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
-import { union, inits, tails, some, creator, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, creation, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { textlink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, shift, push } from 'spica/array';
@@ -18,9 +18,10 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.media, 2, 10, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], bind(verify(fmap(open(
   '!',
   guard(context => ~context.state! & State.media,
+  syntax(Syntax.media, 2, 10,
   tails([
     dup(surround(
       '[',
@@ -28,7 +29,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       ']',
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]))),
+  ])))),
   ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
@@ -58,9 +59,9 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       textlink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  }))));
+  })));
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => creator(union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),

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

@@ -18,11 +18,11 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[\n]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\na]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[\\\na]]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[a\n]]')), [['', '[['], 'a\n]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), [['', '[['], 'a\\\n]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\nb]]')), [['', '[['], 'a\nb]]']);
-      assert.deepStrictEqual(inspect(parser('[[a\\\nb]]')), [['', '[['], 'a\\\nb]]']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['', '[['], '*a\nb*]]']);
+      assert.deepStrictEqual(inspect(parser('[[a\n]]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[[a\\\n]]')), undefined);
+      assert.deepStrictEqual(inspect(parser('[[a\nb]]')), 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]b]]')), undefined);
       assert.deepStrictEqual(inspect(parser('[[[a]]')), undefined);

package/src/parser/inline/reference.ts

@@ -1,17 +1,18 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, context, creator, guard, syntax, state, validate, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, creation, guard, syntax, state, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { str, stropt } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { regBlankStart, startLoose, trimNode } from '../visibility';
 import { stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.reference, 6, surround(
+export const reference: ReferenceParser = lazy(() => surround(
   '[[',
   guard(context => ~context.state! & State.reference,
+  syntax(Syntax.reference, 6, 1,
   state(State.annotation | State.reference | State.media,
   startLoose(
   context({ delimiters: undefined },
@@ -19,13 +20,13 @@ export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.
     abbr,
     open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
     some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]]),
-  ])), ']'))),
+  ])), ']')))),
   ']]',
   false,
   ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest)))));
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest, next)));
 
-const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
+const abbr: ReferenceParser.AbbrParser = creation(bind(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
   /^\|?(?=]])|^\|[^\S\n]*/),

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

@@ -8,6 +8,7 @@ describe('Unit: parser/inline/ruby', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser('[(b)')), undefined);
       assert.deepStrictEqual(inspect(parser('[]()')), undefined);
       assert.deepStrictEqual(inspect(parser('[](b)')), undefined);
       assert.deepStrictEqual(inspect(parser('[ ](b)')), undefined);

package/src/parser/inline/ruby.ts

@@ -1,15 +1,15 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, syntax, creator, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creation, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.none, 2, 1, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),
@@ -48,7 +48,7 @@ export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fm
     }
   }))));
 
-const text: RubyParser.TextParser = creator((source, context) => {
+const text: RubyParser.TextParser = creation((source, context) => {
   const acc = [''];
   while (source !== '') {
     assert(source[0] !== '\n');

package/src/parser/inline/strong.ts

@@ -3,20 +3,21 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => syntax(Rule.none, 1, surround(
+export const strong: StrongParser = lazy(() => surround(
   str('**'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('**')),
     open(some(inline, '*'), union([
       emstrong,
       strong,
     ])),
-  ])), '*'),
+  ])), '*')),
   str('**'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/template.ts

@@ -1,18 +1,18 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, syntax, creator, precedence, surround, lazy } from '../../combinator';
+import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { optimize } from './link';
 import { escsource, str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => syntax(Rule.none, 2, surround(
-  '{{', some(union([bracket, escsource]), '}'), '}}', true,
+export const template: TemplateParser = lazy(() => surround(
+  '{{', syntax(Syntax.none, 2, 1, some(union([bracket, escsource]), '}')), '}}', true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
-  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest))));
+  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest, next)));
 
-const bracket: TemplateParser.BracketParser = lazy(() => creator(union([
+const bracket: TemplateParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),

package/src/parser/inline.test.ts

@@ -159,6 +159,7 @@ describe('Unit: parser/inline', () => {
       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)]{c}')), [['<a href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['', '[[[[[[[', '<a href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a href="http://host" target="_blank">http://host</a>', '>'], '']);
       assert.deepStrictEqual(inspect(parser('[~http://host')), [['', '[', '~', '<a href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~a@b')), [['', '[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
@@ -167,7 +168,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['', '[[', '<em>a<br>b</em>', ']', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });

package/src/parser/source/escapable.ts

@@ -1,10 +1,10 @@
 import { EscapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
-export const escsource: EscapableSourceParser = creator(source => {
+export const escsource: EscapableSourceParser = creation(source => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/str.ts

@@ -1,19 +1,19 @@
 import { undefined } from 'spica/global';
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
 export function str(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m && m[0].length > 0
@@ -26,13 +26,13 @@ export function stropt(pattern: string | RegExp): StrParser;
 export function stropt(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m

package/src/parser/source/text.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { union, creator, focus } from '../../combinator';
+import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
@@ -9,7 +9,7 @@ export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S#|$/;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = creator((source, context) => {
+export const text: TextParser = creation((source, context) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/unescapable.ts

@@ -1,8 +1,8 @@
 import { UnescapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 
-export const unescsource: UnescapableSourceParser = creator(source => {
+export const unescsource: UnescapableSourceParser = creation(source => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);