securemark 0.293.0 → 0.293.2

package/src/parser/source/unescapable.test.ts

@@ -15,7 +15,7 @@ describe('Unit: parser/source/unescapable', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あい', 'AZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あいAZaz'], '']);
     });
 
     it('space', () => {
@@ -37,8 +37,8 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\', '\\', '\\'], '']);
       assert.deepStrictEqual(inspect(parser('\\ '), ctx), [['\\', ' '], '']);
       assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['\\', '_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\`'), ctx), [['\\', '`'], '']);
       assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['\\', '　'], '']);
       assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);

package/src/parser/source/unescapable.ts

@@ -1,9 +1,11 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace, nonAlphanumeric, ASCII, isBlank, isAlphanumeric, isASCII } from './text';
+import { nonWhitespace, isBlank, next } from './text';
 import { html } from 'typed-dom/dom';
 
+export const delimiter = /(?=(?=[\x00-\x7F])[^0-9A-Za-z]|(?<=[\x00-\x7F])[^\x00-\x7F])/g;
+
 export const unescsource: UnescapableSourceParser = ({ context }) => {
   const { source, position } = context;
   if (position === source.length) return;
@@ -25,23 +27,13 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
     default:
       assert(char !== '\n');
       if (context.sequential) return [[char]];
-      nonAlphanumeric.lastIndex = position + 1;
       nonWhitespace.lastIndex = position + 1;
-      ASCII.lastIndex = position + 1;
       const b = isBlank(source, position);
       let i = b
         ? nonWhitespace.test(source)
           ? nonWhitespace.lastIndex - 1
           : source.length
-        : isAlphanumeric(char)
-          ? nonAlphanumeric.test(source)
-            ? nonAlphanumeric.lastIndex - 1
-            : source.length
-          : !isASCII(char)
-            ? ASCII.test(source)
-              ? ASCII.lastIndex - 1
-              : source.length
-            : position + 1;
+        : next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);

package/src/parser/visibility.ts

@@ -1,15 +1,15 @@
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
 import { Parser, Input, eval, failsafe } from '../combinator/data/parser';
-import { union, some, verify, convert, fmap } from '../combinator';
+import { convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
-import { linebreak, unescsource } from './source';
 import { invisibleHTMLEntityNames } from './api/normalize';
 import { push } from 'spica/array';
 
 export namespace blank {
   export const line = new RegExp(
-    /^(?:\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>|\\$)+$/.source
+    // TODO: 行全体をエスケープ
+    /^(?:[^\S\r\n])*(?!\s)(\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>|\\$)+$/mg.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'gm');
   export const start = new RegExp(
@@ -19,31 +19,28 @@ export namespace blank {
 
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
-  return union([
-    convert(
-      source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
-      verify(parser, (ns, { source, position }) => position === source.length && hasVisible(ns)),
-      false),
-    some(union([linebreak, unescsource])),
-  ]);
-}
-function hasVisible(
-  nodes: readonly (HTMLElement | string)[],
-): 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 (node.classList.contains('reference')) return true;
-      //if (state & State.media ^ State.media &&
-      //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
-    }
-  }
-  return false;
+  return convert(
+    source => source.replace(blank.line, `${Command.Escape}$1`),
+    parser,
+    false);
 }
+//function hasVisible(
+//  nodes: readonly (HTMLElement | string)[],
+//): 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 (node.classList.contains('reference')) return true;
+//      //if (state & State.media ^ State.media &&
+//      //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
+//    }
+//  }
+//  return false;
+//}
 
 export function blankWith(delimiter: string | RegExp): RegExp;
 export function blankWith(starts: '' | '\n', delimiter: string | RegExp): RegExp;
@@ -79,6 +76,7 @@ export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N> {
       ? parser(input)
       : undefined;
 }
+const wbr = /<wbr[^\S\n]*>/y;
 function isTightStart(input: Input<MarkdownParser.Context>, except?: string): boolean {
   const { context } = input;
   const { source, position } = context;
@@ -103,10 +101,11 @@ function isTightStart(input: Input<MarkdownParser.Context>, except?: string): bo
       context.position = position;
       return true;
     case '<':
+      wbr.lastIndex = position;
       switch (true) {
         case source.length - position >= 5
           && source.startsWith('<wbr', position)
-          && (source[position + 5] === '>' || /^<wbr[^\S\n]*>/.test(source.slice(position))):
+          && (source[position + 5] === '>' || wbr.test(source)):
           return false;
       }
       return true;
@@ -168,18 +167,19 @@ export function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
+    if (position === source.length) return;
     const reg = blank.start;
     reg.lastIndex = position;
     reg.test(source);
     context.position = reg.lastIndex || position;
-    return parser(input);
+    return context.position === source.length
+      ? [[]]
+      : 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> {
-  return fmap(
-    parser,
-    trimBlankNodeEnd);
+  return fmap(parser, trimBlankNodeEnd);
 }
 //export function trimBlankNode<N extends HTMLElement | string>(nodes: N[]): N[] {
 //  return trimBlankNodeStart(trimBlankNodeEnd(nodes));

package/src/combinator/control/manipulation/trim.test.ts

@@ -1,23 +0,0 @@
-import { trim } from './trim';
-import { input } from '../../data/parser';
-import { inspect } from '../../../debug.test';
-
-describe('Unit: combinator/trim', () => {
-  describe('trim', () => {
-    const { context: ctx } = input('', {});
-
-    it('', () => {
-      const parser = trim(({ context }) => { context.position = context.source.length; return [[context.source]]; });
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('a\n', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input('a \n', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input(' a', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input(' a ', ctx)), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser(input(' a \n b \n', ctx)), ctx), [['a \n b'], '']);
-    });
-
-  });
-
-});

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

@@ -1,17 +0,0 @@
-import { Parser } from '../../data/parser';
-import { convert } from './convert';
-
-export function trim<P extends Parser<unknown>>(parser: P): P;
-export function trim<N>(parser: Parser<N>): Parser<N> {
-  return convert(source => source.trim(), parser, false);
-}
-
-export function trimStart<P extends Parser<unknown>>(parser: P): P;
-export function trimStart<N>(parser: Parser<N>): Parser<N> {
-  return convert(source => source.trimStart(), parser, true);
-}
-
-export function trimEnd<P extends Parser<unknown>>(parser: P): P;
-export function trimEnd<N>(parser: Parser<N>): Parser<N> {
-  return convert(source => source.trimEnd(), parser, false);
-}