securemark 0.257.3 → 0.258.2

package/src/parser/inline/reference.ts

@@ -1,35 +1,29 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, validate, guard, context, precedence, creator, recursion, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, creator, guard, syntax, state, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { str, stropt } from '../source';
-import { regBlankStart, startLoose, trimNode, stringify } from '../util';
+import { Rule, 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('[[', creator(recursion(precedence(6, surround(
+export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.reference, 6, surround(
   '[[',
-  guard(context => context.syntax?.inline?.reference ?? true,
+  guard(context => ~context.state! & State.reference,
+  state(State.annotation | State.reference | State.media,
   startLoose(
-  context({ syntax: { inline: {
-    annotation: false,
-    reference: false,
-    media: false,
-    // Redundant
-    //index: true,
-    //label: true,
-    //link: true,
-    //autolink: true,
-  }}, delimiters: undefined },
+  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],
-  ([, 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(
   '^',

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,14 +1,15 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, validate, verify, focus, creator, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creator, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { isStartTightNodes } from '../util';
+import { Rule } 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('[', creator(fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),

package/src/parser/inline/shortmedia.ts

@@ -1,10 +1,11 @@
 import { ShortmediaParser } from '../inline';
-import { union, rewrite, guard, open, convert } from '../../combinator';
+import { union, guard, rewrite, open, convert } from '../../combinator';
 import { url } from './autolink/url';
 import { media } from './media';
+import { State } from '../context';
 
 export const shortmedia: ShortmediaParser = rewrite(
-  guard(context => context.syntax?.inline?.media ?? true,
+  guard(context => ~context.state! & State.media,
   open('!', url)),
   convert(
     source => `!{ ${source.slice(1)} }`,

package/src/parser/inline/strong.ts

@@ -1,13 +1,14 @@
 import { StrongParser } from '../inline';
-import { union, some, precedence, creator, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { startTight, blankWith } from '../util';
+import { Rule } from '../context';
+import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => creator(precedence(1, surround(
+export const strong: StrongParser = lazy(() => syntax(Rule.none, 1, surround(
   str('**'),
   startTight(some(union([
     some(inline, blankWith('**')),
@@ -18,4 +19,4 @@ export const strong: StrongParser = lazy(() => creator(precedence(1, surround(
   ])), '*'),
   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.test.ts

@@ -10,7 +10,7 @@ describe('Unit: parser/inline/template', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('{')), undefined);
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
-      assert.deepStrictEqual(inspect(parser('{{')), undefined);
+      assert.deepStrictEqual(inspect(parser('{{')), [['', '{{'], '']);
       assert.deepStrictEqual(inspect(parser('{{\\}}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{a}b}')), undefined);
       assert.deepStrictEqual(inspect(parser('{{{a}}')), undefined);

package/src/parser/inline/template.ts

@@ -1,17 +1,20 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, rewrite, precedence, creator, surround, lazy } from '../../combinator';
+import { union, some, syntax, creator, precedence, surround, lazy } from '../../combinator';
+import { optimize } from './link';
 import { escsource, str } from '../source';
+import { Rule } from '../context';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => creator(precedence(2, rewrite(
-  surround('{{', some(union([bracket, escsource]), '}'), '}}', true),
-  source => [[html('span', { class: 'template' }, source.replace(/\x1B/g, ''))], '']))));
+export const template: TemplateParser = lazy(() => syntax(Rule.none, 2, surround(
+  '{{', 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, next))));
 
-const bracket: TemplateParser.BracketParser = lazy(() => union([
+const bracket: TemplateParser.BracketParser = lazy(() => creator(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]),
   surround(str('"'), precedence(8, some(escsource, /^"|^\\?\n/)), str('"'), true),
-]));
+])));

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,7 @@ 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*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);
     });

package/src/parser/locale.ts

@@ -2,6 +2,7 @@ import { Parser } from '../combinator/data/parser';
 import { fmap } from '../combinator';
 import { japanese } from './locale/ja';
 import { html } from 'typed-dom/dom';
+import { duffEach } from 'spica/duff';
 
 export function localize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLElement | string> {
@@ -10,13 +11,11 @@ export function localize(parser: Parser<HTMLElement | string>): Parser<HTMLEleme
     const el = ns.length === 1 && typeof ns[0] === 'object'
       ? ns[0]
       : html('div', ns);
-    const es = el.querySelectorAll('.linebreak:not(:empty)');
-    for (let i = 0, len = es.length; i < len; ++i) {
-      const sb = es[i];
-      assert(sb.firstChild!.textContent === ' ');
-      if (!check(sb)) continue;
-      sb.firstChild!.remove();
-    }
+    duffEach(el.querySelectorAll('.linebreak:not(:empty)'), el => {
+      assert(el.firstChild!.textContent === ' ');
+      if (!check(el)) return;
+      el.firstChild!.remove();
+    });
     return ns;
   });
 }

package/src/parser/processor/footnote.ts

@@ -2,6 +2,7 @@ import { undefined, Infinity, Map, Node } from 'spica/global';
 import { text } from '../inline/extension/indexee';
 import { frag, html, define } from 'typed-dom/dom';
 import { MultiMap } from 'spica/multimap';
+import { duffEach, duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 export function* footnote(
@@ -12,7 +13,7 @@ export function* footnote(
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
   // Bug: Firefox
   //target.querySelectorAll(`:scope > .annotations`).forEach(el => el.remove());
-  target.querySelectorAll(`.annotations`).forEach(el => el.parentNode === target && el.remove());
+  duffEach(target.querySelectorAll(`.annotations`), el => el.parentNode === target && el.remove());
   yield* reference(target, footnotes?.references, opts, bottom);
   yield* annotation(target, footnotes?.annotations, opts, bottom);
   return;
@@ -40,8 +41,9 @@ function build(
     const titles = new Map<string, string>();
     // Bug: Firefox
     //const splitters = push([], target.querySelectorAll(`:scope > :is(${splitter ?? '_'})`));
-    const splitters = push([], target.querySelectorAll(splitter ?? '_'))
-      .filter(el => el.parentNode === target);
+    const splitters = duffReduce(target.querySelectorAll(splitter ?? '_'), (acc, el) =>
+      el.parentNode === target ? push(acc, [el]) : acc
+    , [] as Element[]);
     let count = 0;
     let total = 0;
     let style: 'count' | 'abbr';

package/src/parser/source/text.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { union, focus, creator } from '../../combinator';
+import { union, creator, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 

package/src/parser/util.ts

@@ -1,223 +1,3 @@
-import { undefined } from 'spica/global';
-import { MarkdownParser } from '../../markdown';
-import { Parser, eval } from '../combinator/data/parser';
-import { union, some, verify, convert, fmap } from '../combinator';
-import { unsafehtmlentity } from './inline/htmlentity';
-import { linebreak, unescsource } from './source';
-import { invisibleHTMLEntityNames } from './api/normalize';
-import { memoize, reduce } from 'spica/memoize';
-import { push } from 'spica/array';
-
-export function clean<P extends Parser<unknown>>(parser: P): P;
-export function clean<T>(parser: Parser<T, MarkdownParser.Context>): Parser<T, MarkdownParser.Context> {
-  const clean = memoize<MarkdownParser.Context, MarkdownParser.Context>(context => ({
-    resources: context.resources,
-    precedence: context.precedence,
-    delimiters: context.delimiters,
-    host: context.host,
-    url: context.url,
-    id: context.id,
-    header: context.header,
-    cache: context.caches,
-  }), new WeakMap());
-  return (source, context) =>
-    parser(source, context.syntax ? clean(context) : context);
-}
-
-export const regBlankStart = new RegExp(
-  /^(?:\\?[^\S\n]|&IHN;|<wbr>)+/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
-
-export function blankWith(delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter: string | RegExp): RegExp;
-export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): RegExp {
-  if (delimiter === undefined) return blankWith('', starting);
-  return new RegExp(String.raw
-    `^(?:(?=${
-      starting
-    })(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr>)${starting && '+'})?${
-      typeof delimiter === 'string' ? delimiter.replace(/[*+()\[\]]/g, '\\$&') : delimiter.source
-    }`);
-}
-
-export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  const blankline = new RegExp(
-    /^(?:\\$|\\?[^\S\n]|&IHN;|<wbr>)+$/.source.replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
-    'gm');
-  return union([
-    convert(
-      source => source.replace(blankline, line => line.replace(/[\\&<]/g, '\x1B$&')),
-      verify(parser, (ns, rest, context) => !rest && hasVisible(ns, context))),
-    some(union([linebreak, unescsource])),
-  ]);
-}
-function hasVisible(
-  nodes: readonly (HTMLElement | string)[],
-  { syntax: { inline: { media = true } = {} } = {} }: MarkdownParser.Context = {},
-): boolean {
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
-    if (typeof node === 'string') {
-      if (node && node.trimStart()) return true;
-    }
-    else {
-      if (node.innerText.trimStart()) return true;
-      if (media && (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
-    }
-  }
-  return false;
-}
-
-export function startLoose<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
-export function startLoose<T extends HTMLElement | string>(parser: Parser<T>, except?: string): Parser<T> {
-  return (source, context) =>
-    isStartLoose(source, context, except)
-      ? parser(source, context)
-      : undefined;
-}
-const isStartLoose = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
-  return isStartTight(source.replace(regBlankStart, ''), context, except);
-}, (source, _, except = '') => `${source}\x1E${except}`);
-
-export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
-export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
-  return (source, context) =>
-    isStartTight(source, context, except)
-      ? parser(source, context)
-      : undefined;
-}
-const isStartTight = reduce((source: string, context: MarkdownParser.Context, except?: string): boolean => {
-  if (source === '') return true;
-  if (except && source.slice(0, except.length) === except) return false;
-  switch (source[0]) {
-    case ' ':
-    case '　':
-    case '\t':
-    case '\n':
-      return false;
-    case '\\':
-      return source[1]?.trimStart() !== '';
-    case '&':
-      switch (true) {
-        case source.length > 2
-          && source[1] !== ' '
-          && eval(unsafehtmlentity(source, context))?.[0]?.trimStart() === '':
-          return false;
-      }
-      return true;
-    case '<':
-      switch (true) {
-        case source.length >= 5
-          && source[1] === 'w'
-          && source.slice(0, 5) === '<wbr>':
-          return false;
-      }
-      return true;
-    default:
-      return source[0].trimStart() !== '';
-  }
-}, (source, _, except = '') => `${source}\x1E${except}`);
-
-export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-  if (nodes.length === 0) return true;
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
-    if (isVisible(node)) return true;
-    if (typeof node === 'object') {
-      if (node.tagName === 'BR') break;
-      if (node.className === 'linebreak') break;
-    }
-  }
-  return false;
-}
-export function isStartTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-  if (nodes.length === 0) return true;
-  return isVisible(nodes[0], 0);
-}
-//export function isEndTightNodes(nodes: readonly (HTMLElement | string)[]): boolean {
-//  if (nodes.length === 0) return true;
-//  return isVisible(nodes[nodes.length - 1], -1);
-//}
-function isVisible(node: HTMLElement | string, strpos?: number): boolean {
-  switch (typeof node) {
-    case 'string':
-      const char = node && strpos !== undefined
-        ? node[strpos >= 0 ? strpos : node.length + strpos]
-        : node;
-      switch (char) {
-        case '':
-        case ' ':
-        case '\t':
-        case '\n':
-          return false;
-        default:
-          return char.trimStart() !== '';
-      }
-    default:
-      switch (node.tagName) {
-        case 'BR':
-        case 'WBR':
-          return false;
-        case 'SPAN':
-          return node.className !== 'linebreak';
-        default:
-          return true;
-      }
-  }
-}
-
-export function trimBlank<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlank<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return trimBlankStart(trimBlankEnd(parser));
-}
-export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
-export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
-  return convert(
-    reduce(source => source.replace(regBlankStart, '')),
-    parser);
-}
-export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
-export function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
-  return fmap(
-    parser,
-    trimNodeEnd);
-}
-export function trimNode<T extends HTMLElement | string>(nodes: T[]): T[] {
-  return trimNodeStart(trimNodeEnd(nodes));
-}
-function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
-    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
-    if (typeof node === 'string') {
-      const pos = node.trimStart().length;
-      if (pos > 0) {
-        nodes[0] = node.slice(-pos) as T;
-        break;
-      }
-    }
-    nodes.shift();
-  }
-  return nodes;
-}
-function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
-  const skip = nodes.length > 0 &&
-    typeof nodes[nodes.length - 1] === 'object' &&
-    nodes[nodes.length - 1]['className'] === 'indexer'
-    ? [nodes.pop()!]
-    : [];
-  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[nodes.length - 1], -1);) {
-    if (typeof node === 'string') {
-      const pos = node.trimEnd().length;
-      if (pos > 0) {
-        nodes[nodes.length - 1] = node.slice(0, pos) as T;
-        break;
-      }
-    }
-    nodes.pop();
-  }
-  return push(nodes, skip);
-}
-
 export function stringify(nodes: readonly (HTMLElement | string)[]): string {
   let acc = '';
   for (let i = 0; i < nodes.length; ++i) {