securemark 0.293.5 → 0.294.0

package/src/parser/source/line.ts

@@ -1,10 +1,11 @@
 import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
+import { List } from '../../combinator/data/parser';
 
 export const anyline: AnyLineParser = input => {
   const { context } = input;
   const { source, position } = context;
   context.position = source.indexOf('\n', position) + 1 || source.length;
-  return [[]];
+  return new List();
 };
 const regEmptyline = /[^\S\n]*(?:$|\n)/y;
 export const emptyline: EmptyLineParser = input => {
@@ -15,7 +16,7 @@ export const emptyline: EmptyLineParser = input => {
   const i = regEmptyline.lastIndex;
   if (i === 0) return;
   context.position = i;
-  return [[]];
+  return new List();
 };
 const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
 export const contentline: ContentLineParser = input => {
@@ -26,5 +27,5 @@ export const contentline: ContentLineParser = input => {
   const i = regContentline.lastIndex;
   if (i === 0) return;
   context.position = i;
-  return [[]];
+  return new List();
 }

package/src/parser/source/str.ts

@@ -1,5 +1,5 @@
 import { StrParser } from '../source';
-import { Parser } from '../../combinator/data/parser';
+import { Parser, List, Data } from '../../combinator/data/parser';
 import { matcher } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
@@ -17,6 +17,6 @@ export function strs(pattern: string): Parser<string> {
       acc += pattern;
       context.position += pattern.length;
     }
-    return [[acc]];
+    return new List([new Data(acc)]);
   };
 }

package/src/parser/source/text.ts

@@ -1,5 +1,6 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
@@ -17,26 +18,26 @@ export const text: TextParser = input => {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
-      return [[]];
+      return new List();
     case Command.Escape:
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return [[]];
+          return new List();
         case '\n':
           assert(char !== Command.Escape);
-          return [[]];
+          return new List();
         default:
           consume(1, context);
           context.position += 1;
-          return [[source.slice(position + 1, context.position)]];
+          return new List([new Data(source.slice(position + 1, context.position))]);
       }
     case '\n':
       context.linebreak ||= source.length - position;
-      return [[html('br')]];
+      return new List([new Data(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return [[char]];
+      if (context.sequential) return new List([new Data(char)]);
       nonWhitespace.lastIndex = position + 1;
       const s = canSkip(source, position);
       let i = s
@@ -54,8 +55,8 @@ export const text: TextParser = input => {
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
       return position === context.position || s && !linestart || lineend
-        ? [[]]
-        : [[source.slice(position, context.position)]];
+        ? new List()
+        : new List([new Data(source.slice(position, context.position))]);
   }
 };
 

package/src/parser/source/unescapable.ts

@@ -1,5 +1,6 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { nonWhitespace, canSkip, next } from './text';
 import { html } from 'typed-dom/dom';
@@ -16,17 +17,17 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
-      return [[]];
+      return new List();
     case Command.Escape:
       consume(1, context);
       context.position += 1;
-      return [[source.slice(position + 1, position + 2)]];
+      return new List([new Data(source.slice(position + 1, position + 2))]);
     case '\n':
       context.linebreak ||= source.length - position;
-      return [[html('br')]];
+      return new List([new Data(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return [[char]];
+      if (context.sequential) return new List([new Data(char)]);
       nonWhitespace.lastIndex = position + 1;
       let i = canSkip(source, position)
         ? nonWhitespace.test(source)
@@ -37,6 +38,6 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       i -= position;
       consume(i - 1, context);
       context.position += i - 1;
-      return [[source.slice(position, context.position)]];
+      return new List([new Data(source.slice(position, context.position))]);
   }
 };

package/src/parser/util.ts

@@ -1,28 +1,34 @@
 import { min } from 'spica/alias';
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { Parser, Result, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
 import { define } from 'typed-dom/dom';
 
-export function repeat<P extends Parser<HTMLElement |  string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
-export function repeat<N extends HTMLElement |  string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: MarkdownParser.Context) => N[], termination: (acc: N[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
-  const acc = [];
+export function* unwrap<N>(nodes: List<Data<N>>): Iterable<N> {
+  for (const node of nodes) {
+    yield node.value;
+  }
+}
+
+export function repeat<P extends Parser<HTMLElement | string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<Node<P>>>, termination?: (acc: List<Data<Node<P>>>, context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
+export function repeat<N extends HTMLElement | string>(symbol: string, parser: Parser<N>, cons: (nodes: List<Data<N>>, context: MarkdownParser.Context) => List<Data<N>>, termination: (acc: List<Data<N>>, context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
+  const acc = new List<Data<string | N>>();
   if (prefix > 0) {
-    acc.push(symbol[0].repeat(prefix));
+    acc.push(new Data(symbol[0].repeat(prefix)));
   }
-  acc.push(...nodes);
+  acc.import(nodes);
   if (postfix > 0) {
     const { source, position } = context;
-    acc.push(source.slice(position, position + postfix));
+    acc.push(new Data(source.slice(position, position + postfix)));
     context.position += postfix;
   }
-  return [acc];
+  return acc;
 }): Parser<string | N, MarkdownParser.Context> {
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
     assert(source.startsWith(symbol, context.position));
-    let nodes: N[] = [];
+    let nodes = new List<Data<N>>();
     let i = symbol.length;
     while (source[context.position + i] === source[context.position]) ++i;
     context.position += i;
@@ -39,7 +45,7 @@ export function repeat<N extends HTMLElement |  string>(symbol: string, parser:
       context.buffer = buf;
       if (result === undefined) break;
       nodes = eval(result);
-      switch (nodes.at(-1)) {
+      switch (nodes.last?.value) {
         case Command.Cancel:
           assert(!source.startsWith(symbol, context.position));
           nodes.pop();
@@ -105,10 +111,9 @@ export function unmarkInvalid<N extends HTMLElement>(el: N): N {
   });
 }
 
-export function stringify(nodes: readonly (HTMLElement | string)[]): string {
+export function stringify(nodes: Iterable<HTMLElement | string>): string {
   let acc = '';
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
+  for (const node of nodes) {
     if (typeof node === 'string') {
       assert(!node.includes('\n'));
       acc += node;

package/src/parser/visibility.ts

@@ -1,10 +1,9 @@
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { Parser, Input, eval, failsafe } from '../combinator/data/parser';
+import { Parser, Input, List, Data, eval, failsafe } from '../combinator/data/parser';
 import { convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
 import { invisibleHTMLEntityNames } from './api/normalize';
-import { push } from 'spica/array';
 
 export namespace blank {
   export const line = new RegExp(
@@ -94,7 +93,7 @@ function isTightStart(input: Input<MarkdownParser.Context>, except?: string): bo
       switch (true) {
         case source.length - position > 2
           && source[position + 1] !== ' '
-          && eval(unsafehtmlentity(input))?.[0]?.trimStart() === '':
+          && eval(unsafehtmlentity(input))?.head?.value.trimStart() === '':
           context.position = position;
           return false;
       }
@@ -114,18 +113,17 @@ function isTightStart(input: Input<MarkdownParser.Context>, except?: string): bo
   }
 }
 
-export function isLooseNodeStart(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isLooseNodeStart(nodes: List<Data<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
+  for (const { value: node } of nodes) {
     if (isVisible(node)) return true;
     if (typeof node === 'object' && node.tagName === 'BR') break;
   }
   return false;
 }
-export function isTightNodeStart(nodes: readonly (HTMLElement | string)[]): boolean {
+export function isTightNodeStart(nodes: List<Data<HTMLElement | string>>): boolean {
   if (nodes.length === 0) return true;
-  return isVisible(nodes[0], 0);
+  return isVisible(nodes.head!.value, 0);
 }
 //export function isTightNodeEnd(nodes: readonly (HTMLElement | string)[]): boolean {
 //  if (nodes.length === 0) return true;
@@ -173,12 +171,12 @@ export function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
     reg.test(source);
     context.position = reg.lastIndex || position;
     return context.position === source.length
-      ? [[]]
+      ? new List()
       : parser(input);
   });
 }
 export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlankEnd<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
+export function trimBlankEnd<N extends HTMLElement>(parser: Parser<N>): Parser<string | N> {
   return fmap(parser, trimBlankNodeEnd);
 }
 //export function trimBlankNode<N extends HTMLElement | string>(nodes: N[]): N[] {
@@ -200,21 +198,22 @@ export function trimBlankEnd<N extends HTMLElement | string>(parser: Parser<N>):
 //  }
 //  return nodes;
 //}
-export function trimBlankNodeEnd<N extends HTMLElement | string>(nodes: N[]): N[] {
+export function trimBlankNodeEnd<N extends HTMLElement>(nodes: List<Data<string | N>>): List<Data<string | N>> {
   const skip = nodes.length > 0 &&
-    typeof nodes.at(-1) === 'object' &&
-    nodes.at(-1)!['className'] === 'indexer'
-    ? [nodes.pop()!]
-    : [];
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes.at(-1)!, -1);) {
-    if (typeof node === 'string') {
-      const str = node.trimEnd();
+    typeof nodes.last?.value === 'object' &&
+    nodes.last.value.className === 'indexer'
+    ? nodes.pop()
+    : undefined;
+  for (let node = nodes.last; nodes.length > 0 && !isVisible((node = nodes.last!).value, -1);) {
+    if (typeof node.value === 'string') {
+      const str = node.value.trimEnd();
       if (str.length > 0) {
-        nodes[nodes.length - 1] = str as N;
+        node.value = str;
         break;
       }
     }
     nodes.pop();
   }
-  return push(nodes, skip);
+  skip && nodes.push(skip);
+  return nodes;
 }