securemark 0.257.2 → 0.258.1

package/src/parser/visibility.ts

@@ -0,0 +1,205 @@
+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 { State } from './context';
+import { invisibleHTMLEntityNames } from './api/normalize';
+import { reduce } from 'spica/memoize';
+import { push } from 'spica/array';
+
+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)[],
+  { state = 0 }: 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 (state & State.media ^ State.media &&
+          (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
+    }
+  }
+  return false;
+}
+
+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 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);
+}

package/src/util/info.ts

@@ -1,5 +1,6 @@
 import { Info } from '../..';
 import { scope } from './scope';
+import { duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info {
@@ -20,7 +21,8 @@ export function info(source: DocumentFragment | HTMLElement | ShadowRoot): Info
   };
 
   function find<T extends HTMLElement>(selector: string): T[] {
-    return push([], source.querySelectorAll<T>(selector))
-      .filter(match);
+    return duffReduce(source.querySelectorAll<T>(selector), (acc, el) =>
+      match(el) ? push(acc, [el]) : acc
+    , [] as T[]);
   }
 }

package/src/util/quote.ts

@@ -2,32 +2,30 @@ import { Element } from 'spica/global';
 import { exec } from '../combinator/data/parser';
 import { cite } from '../parser/block/reply/cite';
 import { define } from 'typed-dom/dom';
+import { duffEach } from 'spica/duff';
 
 export function quote(anchor: string, range: Range): string {
   if (exec(cite(`>>${anchor}`, {})) !== '') throw new Error(`Invalid anchor: ${anchor}`);
   fit(range);
   const node = trim(range.cloneContents());
   if (!node.firstChild) return '';
-  for (
-    let es = node.querySelectorAll('code[data-src], .math[data-src], .media[data-src], rt, rp'),
-        i = 0, len = es.length; i < len; ++i) {
-    const el = es[i];
+  duffEach(node.querySelectorAll('code[data-src], .math[data-src], .media[data-src], rt, rp'), el => {
     switch (true) {
       case el.matches('code'):
       case el.matches('.math'):
         define(el, el.getAttribute('data-src')!);
-        continue;
+        return;
       case el.matches('.media'):
         el.replaceWith(
           /[\s{}]/.test(el.getAttribute('data-src')!)
             ? `!{ ${el.getAttribute('data-src')} }`
             : `!{${el.getAttribute('data-src')}}`);
-        continue;
+        return;
       case el.matches('rt, rp'):
         el.remove();
-        continue;
+        return;
     }
-  }
+  });
   if (range.startOffset === 0 &&
       range.startContainer.parentElement?.matches('.cite, .quote') &&
       (!range.startContainer.previousSibling || range.startContainer.previousSibling.nodeName === 'BR')) {
@@ -37,26 +35,25 @@ export function quote(anchor: string, range: Range): string {
     node.prepend(`>>${anchor}\n> `);
     anchor = '';
   }
-  for (let es = node.querySelectorAll('br'), i = 0, len = es.length; i < len; ++i) {
-    const el = es[i];
+  duffEach(node.querySelectorAll('br'), el => {
     if (anchor && el.nextSibling instanceof Element && el.nextSibling.matches('.cite, .quote')) {
       el.replaceWith(`\n>${el.nextSibling.matches('.quote.invalid') ? ' ' : ''}`);
-      continue;
+      return;
     }
     if (anchor && el.parentElement?.closest('.cite, .quote')) {
       el.replaceWith(`\n>${el.parentElement.closest('.quote.invalid') ? ' ' : ''}`);
-      continue;
+      return;
     }
     if (anchor) {
       el.replaceWith(`\n>>${anchor}\n> `);
       anchor = '';
-      continue;
+      return;
     }
     else {
       el.replaceWith(`\n> `);
-      continue;
+      return;
     }
-  }
+  });
   anchor && node.append(`\n>>${anchor}`);
   return node.textContent!;
 }

package/src/util/toc.ts

@@ -1,5 +1,6 @@
 import { undefined } from 'spica/global';
 import { html } from 'typed-dom/dom';
+import { duffEach, duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 
 // Bug: Firefox
@@ -7,16 +8,15 @@ import { push } from 'spica/array';
 const selector = ':is(h1, h2, h3, h4, h5, h6, aside.aside)[id]';
 
 export function toc(source: DocumentFragment | HTMLElement | ShadowRoot): HTMLUListElement {
-  const hs = push([], source.querySelectorAll(selector))
-    .map(el => {
-      assert(el.parentNode === source);
-      switch (el.tagName) {
-        case 'ASIDE':
-          return html(el.firstElementChild!.tagName.toLowerCase() as 'h1', { id: el.id, class: 'aside' }, el.firstElementChild!.cloneNode(true).childNodes);
-        default:
-          return el as HTMLHeadingElement;
-      }
-    });
+  const hs = duffReduce(source.querySelectorAll(selector), (acc, el) => {
+    assert(el.parentNode === source);
+    switch (el.tagName) {
+      case 'ASIDE':
+        return push(acc, [html(el.firstElementChild!.tagName.toLowerCase() as 'h1', { id: el.id, class: 'aside' }, el.firstElementChild!.cloneNode(true).childNodes)]);
+      default:
+        return push(acc, [el as HTMLHeadingElement]);
+    }
+  }, [] as HTMLHeadingElement[]);
   return parse(cons(hs));
 }
 
@@ -35,7 +35,7 @@ function parse(node: Tree, index: string = ''): HTMLUListElement {
         : `${index}.${i}`;
     return html('li',
       push(
-        [html('a', { href: `#${el.id}`, 'data-index': isHeading ? idx : undefined }, fix(el))],
+        [html('a', { href: `#${el.id}`, 'data-index': isHeading ? idx : undefined }, unlink(el.cloneNode(true)))],
         cs.length > 0 ? [parse(cs, idx)] : []));
   }));
 }
@@ -57,11 +57,8 @@ function level(h: HTMLHeadingElement): number {
   return +h.tagName[1];
 }
 
-function fix(h: HTMLHeadingElement): Iterable<Node> {
-  h = h.cloneNode(true);
-  for (let es = h.getElementsByTagName('a'), i = 0, len = es.length; i < len; ++i) {
-    const el = es[i];
-    el.replaceWith(...el.childNodes);
-  }
+function unlink(h: HTMLHeadingElement): Iterable<Node> {
+  duffEach(h.getElementsByTagName('a'), el =>
+    void el.replaceWith(...el.childNodes));
   return h.childNodes;
 }

package/webpack.config.js

@@ -56,6 +56,7 @@ module.exports = env => {
               loader: 'ts-loader',
               options: {
                 onlyCompileBundledFiles: true,
+                allowTsInNodeModules: true,
               },
             },
           ],

package/src/combinator/control/manipulation/context.ts

@@ -1,70 +0,0 @@
-import { undefined, WeakMap } from 'spica/global';
-import { hasOwnProperty, ObjectCreate } from 'spica/alias';
-import { Parser, Ctx, Context } from '../../data/parser';
-import { template } from 'spica/assign';
-import { type } from 'spica/type';
-import { memoize } from 'spica/memoize';
-
-export function guard<P extends Parser<unknown>>(f: (context: Context<P>) => boolean, parser: P): P;
-export function guard<T>(f: (context: Ctx) => boolean, parser: Parser<T>): Parser<T> {
-  return (source, context) =>
-    f(context)
-      ? parser(source, context)
-      : undefined;
-}
-
-export function reset<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function reset<T>(base: Ctx, parser: Parser<T>): Parser<T> {
-  assert(Object.getPrototypeOf(base) === Object.prototype);
-  assert(Object.freeze(base));
-  return (source, context) =>
-    parser(source, inherit(ObjectCreate(context), base));
-}
-
-export function context<P extends Parser<unknown>>(base: Context<P>, parser: P): P;
-export function context<T>(base: Ctx, parser: Parser<T>): Parser<T> {
-  assert(Object.getPrototypeOf(base) === Object.prototype);
-  assert(Object.freeze(base));
-  const override = memoize<Ctx, Ctx>(context => inherit(ObjectCreate(context), base), new WeakMap());
-  return (source, context) =>
-    parser(source, override(context));
-}
-
-const inherit = template((prop, target, source) => {
-  assert(!Object.isSealed(target));
-  assert(Object.isExtensible(target));
-  //assert(Object.freeze(source));
-  if (target[prop] === source[prop]) return;
-  switch (prop) {
-    case 'resources':
-      assert(typeof source[prop] === 'object');
-      assert(target[prop] || !(prop in target));
-      if (prop in target && !hasOwnProperty(target, prop)) return;
-      return target[prop] = ObjectCreate(source[prop]);
-  }
-  assert(!target.hasOwnProperty(prop));
-  switch (type(source[prop])) {
-    case 'Object':
-      assert(Object.getPrototypeOf(source[prop]) === Object.prototype);
-      //assert(Object.freeze(source[prop]));
-      switch (type(target[prop])) {
-        case 'Object':
-          return target[prop] = inherit(ObjectCreate(target[prop]), source[prop]);
-        default:
-          return target[prop] = source[prop];
-      }
-    default:
-      return target[prop] = source[prop];
-  }
-});
-
-export function precedence<P extends Parser<unknown>>(precedence: number, parser: P): P;
-export function precedence<T>(precedence: number, parser: Parser<T>): Parser<T> {
-  return (source, context) => {
-    const p = context.precedence;
-    context.precedence = precedence;
-    const result = parser(source, context);
-    context.precedence = p;
-    return result;
-  };
-}

package/src/combinator/control/manipulation/resource.ts

@@ -1,54 +0,0 @@
-import { Parser } from '../../data/parser';
-
-export function creator<P extends Parser<unknown>>(parser: P): P;
-export function creator<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
-  if (typeof cost === 'function') return creator(1, cost);
-  assert(cost >= 0);
-  return (source, context) => {
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
-    if (resources.recursion <= 0) throw new Error('Too much recursion');
-    --resources.recursion;
-    const result = parser!(source, context);
-    ++resources.recursion;
-    if (result) {
-      resources.budget -= cost;
-    }
-    return result;
-  };
-}
-
-export function uncreator<P extends Parser<unknown>>(parser: P): P;
-export function uncreator<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function uncreator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
-  if (typeof cost === 'function') return uncreator(1, cost);
-  assert(cost >= 0);
-  return (source, context) => {
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
-    if (resources.recursion <= 0) throw new Error('Too much recursion');
-    ++resources.recursion;
-    const result = parser!(source, context);
-    --resources.recursion;
-    if (result) {
-      resources.budget += cost;
-    }
-    return result;
-  };
-}
-
-export function recursion<P extends Parser<unknown>>(parser: P): P;
-export function recursion<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function recursion(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
-  if (typeof cost === 'function') return recursion(1, cost);
-  assert(cost >= 0);
-  return (source, context) => {
-    const { resources = { recursion: 1 } } = context;
-    if (resources.recursion <= 0) throw new Error('Too much recursion');
-    --resources.recursion;
-    const result = parser!(source, context);
-    ++resources.recursion;
-    return result;
-  };
-}