securemark 0.293.4 → 0.294.0

package/src/parser/inline/link.ts

@@ -1,14 +1,14 @@
 import { MarkdownParser } from '../../../markdown';
 import { LinkParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, tails, sequence, subsequence, some, creation, precedence, state, constraint, validate, surround, open, setBacktrack, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { unescsource, str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
-import { invalid, stringify } from '../util';
+import { unwrap, invalid, stringify } from '../util';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 const optspec = {
@@ -24,9 +24,9 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       trimBlankStart(some(union([inline]), ']', [[']', 1]])),
       ']',
       true,
-      ([, ns = []], context) =>
+      ([, ns = new List()], context) =>
         context.linebreak === 0
-          ? [push(ns, [Command.Separator])]
+          ? ns.push(new Data(Command.Separator)) && ns
           : undefined,
       undefined,
       [3 | Backtrack.bracket, 3 | Backtrack.link, 2 | Backtrack.ruby])),
@@ -42,12 +42,12 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
         if (!bs) return;
         const head = context.position - context.range!;
         setBacktrack(context, [2 | Backtrack.link], head);
-        return [push(unshift(as, bs), [Command.Cancel])];
+        return as.import(bs).push(new Data(Command.Cancel)) && as;
       },
       [3 | Backtrack.link])),
   ]),
-  ([content, params]: [(HTMLElement | string)[], string[]], context) => {
-    if (content.at(-1) === Command.Separator) {
+  ([{ value: content }, { value: params = undefined } = {}], context) => {
+    if (content.last!.value === Command.Separator) {
       content.pop();
       if (params === undefined) {
         const head = context.position - context.range!;
@@ -55,37 +55,37 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
       }
     }
     else {
-      params = content as string[];
-      content = [];
+      params = content as List<Data<string>>;
+      content = new List();
     }
-    if (params.at(-1) === Command.Cancel) {
+    if (params.last!.value === Command.Cancel) {
       params.pop();
-      return [[
-        html('span',
+      return new List([
+        new Data(html('span',
           {
             class: 'invalid',
             ...invalid('link', 'syntax', 'Missing the closing symbol "}"')
           },
-          context.source.slice(context.position - context.range!, context.position))
-      ]];
+          context.source.slice(context.position - context.range!, context.position)))
+      ]);
     }
-    assert(!html('div', content).querySelector('a, .media, .annotation, .reference'));
-    assert(content[0] !== '');
+    assert(!html('div', unwrap(content)).querySelector('a, .media, .annotation, .reference'));
+    assert(content.head?.value !== '');
     if (content.length !== 0 && trimBlankNodeEnd(content).length === 0) return;
-    return [[parse(defrag(content), params, context)]];
+    return new List([new Data(parse(content, params as List<Data<string>>, context))]);
   }))))));
 
 export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State.link | State.media, validate(/[[{]/y, creation(10,
   state(State.linkers,
-  bind(reverse(sequence([
+  bind(sequence([
     dup(surround(
       '[',
       union([media, shortmedia]),
       ']')),
     dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
-  ])),
-  ([params, content = []]: [string[], (HTMLElement | string)[]], context) =>
-    [[parse(defrag(content), params, context)]]))))));
+  ]),
+  ([{ value: content }, { value: params }], context) =>
+    new List([new Data(parse(content, params as List<Data<string>>, context))])))))));
 
 export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
   creation(10,
@@ -96,8 +96,8 @@ export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
       ']')),
     dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
   ])),
-  ([params, content = []], context) =>
-    [[parse(defrag(content), params, context)]])));
+  ([{ value: params }, { value: content } = new Data(new List<Data<string>>())], context) =>
+    new List([new Data(parse(content, params, context))]))));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
   open(/ /y, str(/\S+/y)),
@@ -105,19 +105,18 @@ export const uri: LinkParser.ParameterParser.UriParser = union([
 ]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
-  fmap(str(/ nofollow(?=[ }])/y), () => [` rel="nofollow"`]),
+  fmap(str(/ nofollow(?=[ }])/y), () => new List([new Data(' rel="nofollow"')])),
   str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ }])/yi),
   str(/ [^\s{}]+/y),
 ]);
 
 function parse(
-  content: readonly (string | HTMLElement)[],
-  params: string[],
+  content: List<Data<string | HTMLElement>>,
+  params: List<Data<string>>,
   context: MarkdownParser.Context,
 ): HTMLAnchorElement {
   assert(params.length > 0);
-  assert(params.every(p => typeof p === 'string'));
-  const INSECURE_URI = params.shift()!;
+  const INSECURE_URI = params.shift()!.value;
   assert(INSECURE_URI === INSECURE_URI.trim());
   assert(!INSECURE_URI.match(/\s/));
   let uri: ReadonlyURL | undefined;
@@ -135,12 +134,12 @@ function parse(
     context.host?.origin || location.origin);
   return el.classList.contains('invalid')
     ? el
-    : define(el, attributes('link', optspec, params)[0]);
+    : define(el, attributes('link', optspec, unwrap(params))[0]);
 }
 
 function elem(
   INSECURE_URI: string,
-  content: readonly (string | HTMLElement)[],
+  content: List<Data<string | HTMLElement>>,
   uri: ReadonlyURL | undefined,
   origin: string,
 ): HTMLAnchorElement {
@@ -155,7 +154,7 @@ function elem(
     case 'https:':
       assert(uri.host);
       switch (true) {
-        case /[0-9a-z]:\S/i.test(stringify(content)):
+        case /[0-9a-z]:\S/i.test(stringify(unwrap(content))):
           type = 'content';
           message = 'URI must not be contained';
           break;
@@ -171,20 +170,19 @@ function elem(
               href: uri.source,
               target: undefined
                 || uri.origin !== origin
-                || typeof content[0] === 'object' && content[0].classList.contains('media')
+                || typeof content.head?.value === 'object' && content.head!.value.classList.contains('media')
                   ? '_blank'
                   : undefined,
             },
             content.length === 0
               ? decode(INSECURE_URI)
-              : content);
+              : defrag(unwrap(content)));
       }
       break;
     case 'tel:':
-      assert(content.length <= 1);
       const tel = content.length === 0
         ? INSECURE_URI
-        : content[0];
+        : stringify(unwrap(content));
       const pattern = /^(?:tel:)?(?:\+(?!0))?\d+(?:-\d+)*$/i;
       switch (true) {
         case content.length <= 1
@@ -198,8 +196,8 @@ function elem(
               href: uri.source,
             },
             content.length === 0
-              ? [INSECURE_URI]
-              : content);
+              ? INSECURE_URI
+              : defrag(unwrap(content)));
         default:
           type = 'content';
           message = 'Invalid content';
@@ -216,7 +214,7 @@ function elem(
     },
     content.length === 0
       ? INSECURE_URI
-      : content);
+      : defrag(unwrap(content)));
 }
 
 export function resolve(uri: string, host: URL | Location, source: URL | Location): string {

package/src/parser/inline/mark.ts

@@ -1,11 +1,11 @@
 import { MarkParser } from '../inline';
 import { State, Recursion, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, state, constraint, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { tightStart, blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mark, validate('==',
@@ -17,12 +17,12 @@ export const mark: MarkParser = lazy(() => constraint(State.linkers & ~State.mar
       open(some(inline, '='), inline),
     ])))),
     '==', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
+    ([, bs], { buffer }) => buffer!.import(bs),
+    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
     (nodes, { id }) => {
-      const el = html('mark', defrag(nodes));
+      const el = html('mark', defrag(unwrap(nodes)));
       define(el, { id: identity('mark', id, signature(el)) });
       return el.id
-        ? [el, html('a', { href: `#${el.id}` })]
-        : [el];
+        ? new List([new Data(el), new Data(html('a', { href: `#${el.id}` }))])
+        : new List([new Data(el)]);
     }))))));

package/src/parser/inline/math.ts

@@ -1,5 +1,6 @@
 import { MathParser } from '../inline';
 import { Backtrack, Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, rewrite, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
 import { invalid } from '../util';
@@ -23,8 +24,8 @@ export const math: MathParser = lazy(() => rewrite(
       /\$(?![-0-9A-Za-z])/y,
       false, undefined, undefined, [3 | Backtrack.bracket]),
   ]),
-  ({ context: { source, caches: { math: cache } = {} } }) => [[
-    cache?.get(source)?.cloneNode(true) ||
+  ({ context: { source, caches: { math: cache } = {} } }) => new List([
+    new Data(cache?.get(source)?.cloneNode(true) ||
     html('span',
       !forbiddenCommand.test(source)
         ? { class: 'math', translate: 'no', 'data-src': source }
@@ -34,8 +35,8 @@ export const math: MathParser = lazy(() => rewrite(
             ...invalid('math', 'content',
               `"${source.match(forbiddenCommand)![0]}" command is forbidden`),
           },
-      source)
-  ]]));
+      source))
+  ])));
 
 const bracket: MathParser.BracketParser = lazy(() => surround(
   str('{'),

package/src/parser/inline/media.ts

@@ -1,14 +1,13 @@
 import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
-import { subinput } from '../../combinator/data/parser';
-import { union, inits, tails, some, creation, recursion, precedence, constraint, verify, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { List, Data, subinput } from '../../combinator/data/parser';
+import { union, inits, tails, some, creation, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { unsafelink, uri, option as linkoption, resolve, decode } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
 import { html, define } from 'typed-dom/dom';
 
 const optspec = {
@@ -21,7 +20,7 @@ Object.setPrototypeOf(optspec, null);
 
 export const media: MediaParser = lazy(() => constraint(State.media, creation(10, open(
   '!',
-  bind(verify(fmap(tails([
+  bind(fmap(tails([
     dup(surround(
       '[',
       precedence(1, some(union([
@@ -31,9 +30,9 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
       ]), ']')),
       ']',
       true,
-      ([, ns = []], context) =>
+      ([, ns = new List()], context) =>
         context.linebreak === 0
-          ? [ns]
+          ? ns
           : undefined,
       undefined,
       [3 | Backtrack.escbracket])),
@@ -47,26 +46,29 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
         if (!bs) return;
         const head = context.position - context.range!;
         setBacktrack(context, [2 | Backtrack.link], head);
-        return [push(unshift(as, bs), [Command.Cancel])];
+        return as.import(bs).push(new Data(Command.Cancel)) && as;
       },
       [3 | Backtrack.link])),
   ]),
-  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
-  ([[text]]) => text === '' || text.trim() !== ''),
-  ([[text], params], context) => {
-    if (params.at(-1) === Command.Cancel) {
+  nodes =>
+    nodes.length === 1
+      ? new List<Data<List<Data<string>>>>([new Data(new List([new Data('')])), nodes.delete(nodes.head!)])
+      : new List<Data<List<Data<string>>>>([new Data(new List([new Data(nodes.head!.value.foldl((acc, { value }) => acc + value, ''))])), nodes.delete(nodes.last!)])),
+  ([{ value: [{ value: text }] }, { value: params }], context) => {
+    if (text && text.trimStart() === '') return;
+    text = text.trim();
+    if (params.last!.value === Command.Cancel) {
       params.pop();
-      return [[
-        html('span',
+      return new List([
+        new Data(html('span',
           {
             class: 'invalid',
             ...invalid('media', 'syntax', 'Missing the closing symbol "}"')
           },
-          '!' + context.source.slice(context.position - context.range!, context.position))
-      ]];
+          '!' + context.source.slice(context.position - context.range!, context.position)))
+      ]);
     }
-    assert(text === text.trim());
-    const INSECURE_URI = params.shift()!;
+    const INSECURE_URI = params.shift()!.value;
     assert(INSECURE_URI === INSECURE_URI.trim());
     assert(!INSECURE_URI.match(/\s/));
     // altが空だとエラーが見えないため埋める。
@@ -85,37 +87,37 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
       || html('img', { class: 'media', 'data-src': uri?.source });
     assert(!el.matches('.invalid'));
     el.setAttribute('alt', text);
-    if (!sanitize(el, uri)) return [[el]];
+    if (!sanitize(el, uri)) return new List([new Data(el)]);
     assert(!el.matches('.invalid'));
-    const [attrs, linkparams] = attributes('media', optspec, params);
+    const [attrs, linkparams] = attributes('media', optspec, unwrap(params));
     define(el, attrs);
     assert(el.matches('img') || !el.matches('.invalid'));
     // Awaiting the generic support for attr().
     if (el.hasAttribute('aspect-ratio')) {
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
-    if (context.state! & State.link) return [[el]];
-    if (cache && cache.tagName !== 'IMG') return [[el]];
+    if (context.state! & State.link) return new List([new Data(el)]);
+    if (cache && cache.tagName !== 'IMG') return new List([new Data(el)]);
     const { source, position } = context;
     return fmap(
       unsafelink as MediaParser,
-      ([link]) => {
+      ([{ value }]) => {
         context.source = source;
         context.position = position;
-        return [define(link, { class: null, target: '_blank' }, [el])];
+        return new List([new Data(define(value, { class: null, target: '_blank' }, [el]))]);
       })
       (subinput(`{ ${INSECURE_URI}${linkparams.join('')} }`, context));
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('"'), precedence(2, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
@@ -124,11 +126,10 @@ const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
     str(/[x:]/y),
     str(/[1-9][0-9]*(?=[ }])/y),
     false,
-    ([[a], [b], [c]]) => [
+    ([[{ value: a }], [{ value: b }], [{ value: c }]]) =>
       b === 'x'
-        ? [`width="${a}"`, `height="${c}"`]
-        : [`aspect-ratio="${a}/${c}"`],
-    ]),
+        ? new List([new Data(`width="${a}"`), new Data(`height="${c}"`)])
+        : new List([new Data(`aspect-ratio="${a}/${c}"`)])),
   linkoption,
 ]));
 

package/src/parser/inline/reference.ts

@@ -1,14 +1,13 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
-import { eval } from '../../combinator/data/parser';
+import { List, Data, eval } from '../../combinator/data/parser';
 import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
-import { unshift, push } from 'spica/array';
-import { invalid } from '../util';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, surround(
   str('[['),
@@ -22,7 +21,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   ([, ns], context) => {
     const { position, range = 0, linebreak = 0 } = context;
     if (linebreak === 0) {
-      return [[html('sup', attributes(ns), [html('span', defrag(trimBlankNodeEnd(ns)))])]];
+      return new List([new Data(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
     }
     else {
       const head = position - range;
@@ -42,13 +41,13 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
     else {
       assert(source[position] === ']');
       if (state & State.annotation) {
-        push(bs, [source[position]]);
+        bs.push(new Data(source[position]));
       }
       context.position += 1;
       let result: ReturnType<typeof textlink>;
       if (source[context.position] !== '{') {
         setBacktrack(context, [2 | Backtrack.link], head + 1);
-        result = [[]];
+        result = new List();
       }
       else {
         result = !isBacktrack(context, [1 | Backtrack.link])
@@ -57,7 +56,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
         context.range = range;
         if (!result) {
           setBacktrack(context, [2 | Backtrack.link], head + 1);
-          result = [[]];
+          result = new List();
         }
       }
       assert(result);
@@ -71,21 +70,21 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
           some(inline, ']', [[']', 1]]),
           str(']'),
           true,
-          ([, cs = [], ds]) =>
-            [push(cs, ds)],
-          ([, cs = []]) => {
+          ([, cs = new List(), ds]) =>
+            cs.import(ds),
+          ([, cs = new List()]) => {
             setBacktrack(context, [2 | Backtrack.link], head);
-            return [cs];
+            return cs;
           })
           ({ context });
         if (state & State.annotation && next) {
-          return [push(push(unshift(as, bs), eval(result)), eval(next))];
+          return (as as List<Data<string | HTMLElement>>).import(bs).import(eval(result!)).import(eval(next));
         }
       }
       context.position = position;
     }
     return state & State.annotation
-      ? [unshift(as, bs)]
+      ? as.import(bs as List<Data<string>>)
       : undefined;
   },
   [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));
@@ -98,22 +97,22 @@ const abbr: ReferenceParser.AbbrParser = surround(
   true,
   ([, ns], context) => {
     const { source, position, range = 0 } = context;
-    if (!ns) return [['', source.slice(position - range, source[position - 1] === '|' ? position - 1 : position)]];
+    if (!ns) return new List([new Data(''), new Data(source.slice(position - range, source[position - 1] === '|' ? position - 1 : position))]);
     context.position += source[position] === ' ' ? 1 : 0;
-    return [[Command.Separator, ns[0].trimEnd()]];
+    return new List([new Data(Command.Separator), new Data(ns.head!.value.trimEnd())]);
   },
   (_, context) => {
     context.position -= context.range!;
-    return [['']];
+    return new List([new Data('')]);
   });
 
-function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
-  switch (ns[0]) {
+function attributes(ns: List<Data<string | HTMLElement>>): Record<string, string | undefined> {
+  switch (ns.head!.value) {
     case '':
       return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
     case Command.Separator:
-      const abbr = ns[1] as string;
-      ns[0] = ns[1] = '';
+      const abbr = ns.head!.next!.value as string;
+      ns.head!.value = ns.head!.next!.value = '';
       return { class: 'reference', 'data-abbr': abbr };
     default:
       return { class: 'reference' };

package/src/parser/inline/remark.ts

@@ -1,10 +1,10 @@
 import { RemarkParser } from '../inline';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, focus, surround, close, fallback, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { invalid } from '../util';
-import { unshift, push } from 'spica/array';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const remark: RemarkParser = lazy(() => fallback(surround(
@@ -12,13 +12,13 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
   precedence(3, recursion(Recursion.inline,
   some(union([inline]), /\s%\]/y, [[/\s%\]/y, 3]]))),
   close(text, str(`%]`)), true,
-  ([as, bs = [], cs]) => [[
-    html('span', { class: 'remark' }, [
+  ([as, bs = new List(), cs]) => new List([
+    new Data(html('span', { class: 'remark' }, [
       html('input', { type: 'checkbox' }),
-      html('span', defrag(push(unshift(as, bs), cs))),
-    ]),
-  ]],
-  ([as, bs]) => bs && [unshift(as, bs)]),
-  focus(/\[%+(?=\s)/y, ({ context: { source } }) => [[
-    html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source)
-  ]])));
+      html('span', defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))),
+    ])),
+  ]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>)),
+  focus(/\[%+(?=\s)/y, ({ context: { source } }) => new List([
+    new Data(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
+  ]))));