securemark 0.293.5 → 0.294.0

package/src/parser/inline/extension/label.ts

@@ -1,5 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, constraint, clear, surround, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
@@ -16,9 +17,12 @@ export const label: ExtensionParser.LabelParser = constraint(State.label, fmap(
     surround('[', body, ']', false, undefined, undefined, [1 | Backtrack.bracket, 1]),
     body,
   ]),
-  ([text]) => [
-    html('a', { class: 'label', 'data-label': text.slice(text[1] === '-' ? 0 : 1).toLowerCase() }, text),
-  ]));
+  ([{ value }]) => new List([
+    new Data(html('a', {
+      class: 'label',
+      'data-label': value.slice(value[1] === '-' ? 0 : 1).toLowerCase(),
+    }, value)),
+  ])));
 
 export function number(label: string, base: string): string {
   return isFixed(label)

package/src/parser/inline/extension/placeholder.ts

@@ -1,11 +1,11 @@
 import { ExtensionParser } from '../../inline';
 import { Recursion, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { tightStart } from '../../visibility';
 import { invalid } from '../../util';
-import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 // Don't use the symbols already used: !#$%@&*+~=|
@@ -18,13 +18,13 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surroun
   precedence(1, recursion(Recursion.inline,
   tightStart(some(union([inline]), ']', [[']', 1]])))),
   str(']'), false,
-  (_, context) => [[
-    html('span',
+  (_, context) => new List([
+    new Data(html('span',
       {
         class: 'invalid',
         ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
       },
-      context.source.slice(context.position - context.range!, context.position))
-  ]],
-  ([as, bs]) => bs && [unshift(as, bs)],
+      context.source.slice(context.position - context.range!, context.position)))
+  ]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>),
   [3 | Backtrack.bracket]));

package/src/parser/inline/html.ts

@@ -1,13 +1,12 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
-import { Ctx } from '../../combinator/data/parser';
+import { List, Data, Ctx } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
-import { invalid } from '../util';
+import { invalid, unwrap } from '../util';
 import { memoize } from 'spica/memoize';
-import { unshift, push } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
 const tags: readonly string[] = ['wbr', 'bdo', 'bdi'];
@@ -28,10 +27,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       some(union([attribute])),
       open(str(/ ?/y), str('>'), true),
       true,
-      ([as, bs = [], cs], context) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
-      ([as, bs = []], context) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
+      ([as, bs = new List(), cs], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+      ([as, bs = new List()], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(
       new RegExp(String.raw`<(${TAGS.join('|')})(?=[^\S\n]|>)`, 'y'),
       memoize(
@@ -40,8 +39,8 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
           surround(
             str(`<${tag}`), some(attribute), open(str(/ ?/y), str('>'), true),
             true,
-            ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
-            ([as, bs = []]) => [unshift(as, bs)]),
+            ([as, bs = new List(), cs]) => as.import(bs).import(cs),
+            ([as, bs = new List()]) => as.import(bs)),
           // 不可視のHTML構造が可視構造を変化させるべきでない。
           // 可視のHTMLは優先度変更を検討する。
           // このため<>は将来的に共通構造を変化させる可能性があり
@@ -53,10 +52,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
           ])))),
           str(`</${tag}>`),
           true,
-          ([as, bs = [], cs], context) =>
-            [[elem(tag, true, as, bs, cs, context)]],
-          ([as, bs = []], context) =>
-            [[elem(tag, true, as, bs, [], context)]]),
+          ([as, bs = new List(), cs], context) =>
+            new List([new Data(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
+          ([as, bs = new List()], context) =>
+            new List([new Data(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
       ([, tag]) => tag,
       new Map())),
     surround(
@@ -65,10 +64,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       some(union([attribute])),
       open(str(/ ?/y), str('>'), true),
       true,
-      ([as, bs = [], cs], context) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
-      ([as, bs = []], context) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
+      ([as, bs = new List(), cs], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+      ([as, bs = new List()], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
@@ -76,7 +75,7 @@ export const attribute: HTMLParser.AttributeParser = union([
   str(/ [^\s<>]+/y),
 ]);
 
-function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[], context: Ctx): HTMLElement {
+function elem(tag: string, content: boolean, as: readonly string[], bs: List<Data<HTMLElement | string>>, cs: List<Data<string>>, context: Ctx): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<');
   if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, context);
@@ -88,7 +87,7 @@ function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | st
   const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)
   if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
-  return h(tag as 'span', attrs, defrag(bs));
+  return h(tag as 'span', attrs, defrag(unwrap(bs)));
 }
 
 function ielem(type: string, message: string, context: Ctx): HTMLElement {
@@ -105,7 +104,7 @@ const requiredAttributes = memoize(
 export function attributes(
   syntax: string,
   spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
-  params: readonly string[],
+  params: Iterable<string>,
 ): [Record<string, string | undefined>, string[]] {
   assert(spec instanceof Object === false);
   assert(!spec?.['__proto__']);
@@ -113,17 +112,17 @@ export function attributes(
   const remains = [];
   let invalidation = false;
   const attrs: Record<string, string | undefined> = {};
-  for (let i = 0; i < params.length; ++i) {
-    const param = params[i].trimStart();
-    if (param === '') continue;
-    const name = param.split('=', 1)[0];
-    const value = param !== name
-      ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
+  for (const param of params) {
+    const attr = param.trimStart();
+    if (attr === '') continue;
+    const name = attr.split('=', 1)[0];
+    const value = attr !== name
+      ? attr.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
     invalidation ||= name === '' || !spec || name in attrs;
-    if (name === '')continue;
+    if (name === '') continue;
     if (spec && name in spec && !spec[name]) {
-      remains.push(params[i]);
+      remains.push(param);
       continue;
     }
     if (spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined) {

package/src/parser/inline/htmlentity.ts

@@ -1,4 +1,5 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
+import { List, Data } from '../../combinator/data/parser';
 import { union, focus, fmap } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
@@ -10,20 +11,20 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = focus(
     const { source } = context;
     context.position += source.length;
     return source.length > 1 && source.at(-1) === ';'
-      ? [[parser(source) ?? source]]
-      : [[source]];
+      ? new List([new Data(parser(source) ?? source)])
+      : new List([new Data(source)]);
   });
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([text]) => [
-    length === 1 || text.at(-1) !== ';'
-      ? text
-      : html('span', {
+  ([{ value }]) => new List([
+    length === 1 || value.at(-1) !== ';'
+      ? new Data(value)
+      : new Data(html('span', {
           class: 'invalid',
           ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),
-      }, text)
-  ]);
+      }, value))
+  ]));
 
 const parser = (el => (entity: string): string | undefined => {
   if (entity === '
') return ' ';

package/src/parser/inline/insertion.ts

@@ -1,10 +1,10 @@
 import { InsertionParser } from '../inline';
 import { Recursion, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const insertion: InsertionParser = lazy(() => validate('++',
@@ -16,6 +16,6 @@ export const insertion: InsertionParser = lazy(() => validate('++',
       open('\n', some(inline, '+'), true),
     ]))),
     '++', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('ins', defrag(nodes))]))));
+    ([, bs], { buffer }) => buffer!.import(bs),
+    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
+    nodes => new List([new Data(html('ins', defrag(unwrap(nodes))))])))));

package/src/parser/inline/italic.ts

@@ -1,10 +1,10 @@
 import { ItalicParser } from '../inline';
 import { Recursion, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { tightStart, blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 // 可読性のため実際にはオブリーク体を指定する。
@@ -19,6 +19,6 @@ export const italic: ItalicParser = lazy(() => validate('///',
       open(some(inline, '/'), inline),
     ])))),
     '///', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('i', defrag(nodes))]))));
+    ([, bs], { buffer }) => buffer!.import(bs),
+    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
+    nodes => new List([new Data(html('i', defrag(unwrap(nodes))))])))));

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('{'),