securemark 0.258.8 → 0.259.1

package/src/parser/inline/link.ts

@@ -1,7 +1,8 @@
 import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
-import { LinkParser, TextLinkParser } from '../inline';
-import { eval, exec } from '../../combinator/data/parser';
-import { union, inits, tails, subsequence, some, constraint, syntax, creation, precedence, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { MarkdownParser } from '../../../markdown';
+import { LinkParser } from '../inline';
+import { Result, eval, exec } from '../../combinator/data/parser';
+import { union, inits, tails, sequence, some, constraint, syntax, creation, precedence, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
@@ -17,82 +18,62 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => validate(['[', '{'], bind(
+export const link: LinkParser = lazy(() => validate(['[', '{'], union([
+  medialink,
+  textlink,
+])));
+
+const textlink: LinkParser.TextLinkParser = lazy(() =>
   constraint(State.link, false,
-  creation(10,
-  fmap(subsequence([
-    state(State.link,
-    dup(union([
-      surround('[', media, ']'),
-      surround('[', shortmedia, ']'),
-      surround(
-        '[',
-        state(State.annotation | State.reference | State.index | State.label | State.media | State.autolink,
-        syntax(Syntax.link, 2, 0,
-        some(inline, ']', [[/^\\?\n/, 9], [']', 2]]))),
-        ']',
-        true),
-    ]))),
+  syntax(Syntax.link, 2, 10, State.linkable,
+  bind(reverse(tails([
+    dup(surround(
+      '[',
+      some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]]),
+      ']',
+      true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ], nodes => nodes[0][0] !== ''),
-  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []]))),
-  ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
-    assert(content[0] !== '' || params.length === 0);
-    if (content[0] === '') return [content, rest];
-    if (params.length === 0) return;
-    assert(params.every(p => typeof p === 'string'));
+  ])),
+  ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) => {
+    assert(!html('div', content).querySelector('a, .media, .annotation, .reference'));
     if (content.length !== 0 && trimNode(content).length === 0) return;
     for (let source = stringify(content); source;) {
-      const result = autolink(source, context);
+      const result = state(State.autolink, false, autolink)(source, context);
       if (typeof eval(result!)[0] === 'object') return;
       source = exec(result!);
     }
-    assert(!html('div', content).querySelector('a, .media, .annotation, .reference') || (content[0] as HTMLElement).matches('.media'));
-    const INSECURE_URI = params.shift()!;
-    assert(INSECURE_URI === INSECURE_URI.trim());
-    assert(!INSECURE_URI.match(/\s/));
-    const el = elem(
-      INSECURE_URI,
-      defrag(content),
-      new ReadonlyURL(
-        resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
-        context.host?.href || location.href),
-      context.host?.origin || location.origin);
-    if (el.className === 'invalid') return [[el], rest];
-    assert(el.classList.length === 0);
-    return [[define(el, attributes('link', [], optspec, params))], rest];
-  })));
+    return parse(content, params, rest, context);
+  }))));
+
+const medialink: LinkParser.MediaLinkParser = lazy(() =>
+  constraint(State.link | State.media, false,
+  syntax(Syntax.link, 2, 10, State.linkable ^ State.media,
+  bind(reverse(sequence([
+    dup(surround(
+      '[',
+      union([media, shortmedia]),
+      ']')),
+    dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
+  ])),
+  ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) =>
+    parse(content, params, rest, context)))));
 
-export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], bind(
+export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
   creation(10, precedence(2,
-  reverse(tails([
-    dup(surround('[', some(union([unescsource]), ']'), ']')),
+  bind(reverse(tails([
+    dup(surround(
+      '[',
+      some(union([unescsource]), ']'),
+      ']')),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ])))),
-  ([params, content = []], rest, context) => {
-    assert(params[0] === '\r');
-    params.shift();
-    assert(params.every(p => typeof p === 'string'));
-    trimNode(content);
-    const INSECURE_URI = params.shift()!;
-    assert(INSECURE_URI === INSECURE_URI.trim());
-    assert(!INSECURE_URI.match(/\s/));
-    const el = elem(
-      INSECURE_URI,
-      defrag(content),
-      new ReadonlyURL(
-        resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
-        context.host?.href || location.href),
-      context.host?.origin || location.origin);
-    assert(el.className !== 'invalid');
-    assert(el.classList.length === 0);
-    return [[define(el, attributes('link', [], optspec, params))], rest];
-  })));
+  ])),
+  ([params, content = []], rest, context) =>
+    parse(content, params, rest, context)))));
 
-export const uri: LinkParser.ParameterParser.UriParser = fmap(union([
+export const uri: LinkParser.ParameterParser.UriParser = union([
   open(/^[^\S\n]+/, str(/^\S+/)),
   str(/^[^\s{}]+/),
-]), ([uri]) => ['\r', uri]);
+]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
   fmap(str(/^[^\S\n]+nofollow(?=[^\S\n]|})/), () => [` rel="nofollow"`]),
@@ -100,6 +81,29 @@ export const option: LinkParser.ParameterParser.OptionParser = union([
   fmap(str(/^[^\S\n]+[^\s{}]+/), opt => [` \\${opt.slice(1)}`]),
 ]);
 
+function parse(
+  content: (string | HTMLElement)[],
+  params: string[],
+  rest: string,
+  context: MarkdownParser.Context,
+): Result<HTMLAnchorElement, MarkdownParser.Context> {
+  assert(params.length > 0);
+  assert(params.every(p => typeof p === 'string'));
+  const INSECURE_URI = params.shift()!;
+  assert(INSECURE_URI === INSECURE_URI.trim());
+  assert(!INSECURE_URI.match(/\s/));
+  const el = elem(
+    INSECURE_URI,
+    defrag(content),
+    new ReadonlyURL(
+      resolve(INSECURE_URI, context.host ?? location, context.url ?? context.host ?? location),
+      context.host?.href || location.href),
+    context.host?.origin || location.origin);
+  if (el.className === 'invalid') return [[el], rest];
+  assert(el.classList.length === 0);
+  return [[define(el, attributes('link', [], optspec, params))], rest];
+}
+
 export function resolve(uri: string, host: URL | Location, source: URL | Location): string {
   assert(uri);
   assert(uri === uri.trim());

package/src/parser/inline/mark.ts

@@ -3,13 +3,13 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { Syntax } from '../context';
+import { Syntax, State } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
 export const mark: MarkParser = lazy(() => surround(
   str('=='),
-  syntax(Syntax.none, 1, 1,
+  syntax(Syntax.none, 1, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('==')),
     open(some(inline, '='), mark),

package/src/parser/inline/media.ts

@@ -1,14 +1,14 @@
 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 { textlink, uri, option as linkoption, resolve } from './link';
+import { unsafelink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
 import { Syntax, State } from '../context';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, shift, push } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 const optspec = {
   'width': [],
@@ -18,19 +18,19 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], open(
   '!',
   constraint(State.media, false,
-  syntax(Syntax.media, 2, 10,
-  tails([
+  syntax(Syntax.media, 2, 10, State.none,
+  bind(verify(fmap(tails([
     dup(surround(
       '[',
       some(union([unsafehtmlentity, bracket, txt]), ']', [[/^\\?\n/, 9]]),
       ']',
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ])))),
-  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
+  ]),
+  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
     assert(text === text.trim());
@@ -54,12 +54,13 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], bind(verify(
     if (el.hasAttribute('aspect-ratio')) {
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
-    if (context.state! & State.link || cache && cache.tagName !== 'IMG') return [[el], rest];
+    if (context.state! & State.link) return [[el], rest];
+    if (cache && cache.tagName !== 'IMG') return creation(10, (..._) => [[el!], rest])('!', context);
     return fmap(
-      textlink as MediaParser,
+      unsafelink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  })));
+  }))))));
 
 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]),

package/src/parser/inline/reference.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, context, syntax, creation, constraint, state, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, syntax, creation, constraint, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { str, stropt } from '../source';
 import { Syntax, State } from '../context';
@@ -11,15 +11,14 @@ import { html, defrag } from 'typed-dom/dom';
 export const reference: ReferenceParser = lazy(() => surround(
   '[[',
   constraint(State.reference, false,
-  state(State.annotation | State.reference | State.media,
-  syntax(Syntax.reference, 6, 1,
+  syntax(Syntax.reference, 6, 1, State.annotation | State.reference | State.media,
   startLoose(
   context({ delimiters: undefined },
   subsequence([
     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]));

package/src/parser/inline/ruby.ts

@@ -4,12 +4,12 @@ import { eval, exec } from '../../combinator/data/parser';
 import { sequence, syntax, creation, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { Syntax } from '../context';
+import { Syntax, State } 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(Syntax.none, 2, 1, fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.none, 2, 1, State.none, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),

package/src/parser/inline/strong.ts

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

package/src/parser/inline/template.ts

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

package/src/parser/inline.ts

@@ -34,7 +34,6 @@ export import MathParser = InlineParser.MathParser;
 export import ExtensionParser = InlineParser.ExtensionParser;
 export import RubyParser = InlineParser.RubyParser;
 export import LinkParser = InlineParser.LinkParser;
-export import TextLinkParser = InlineParser.TextLinkParser;
 export import HTMLParser = InlineParser.HTMLParser;
 export import InsertionParser = InlineParser.InsertionParser;
 export import DeletionParser = InlineParser.DeletionParser;

package/src/parser/source/text.ts

@@ -2,7 +2,7 @@ import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { union, syntax, focus } from '../../combinator';
 import { str } from './str';
-import { Syntax } from '../context';
+import { Syntax, State } from '../context';
 import { html } from 'typed-dom/dom';
 
 export const delimiter = /[\s\x00-\x7F]|\S[#>]|[（）、。！？][^\S\n]*(?=\\\n)/;
@@ -10,7 +10,7 @@ export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = syntax(Syntax.none, 1, 1, (source, context) => {
+export const text: TextParser = syntax(Syntax.none, 1, 1, State.none, (source, context) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {