securemark 0.298.2 → 0.298.3

package/src/parser/inline/html.ts

@@ -2,7 +2,7 @@ import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
 import { List, Node, Context } from '../../combinator/data/parser';
 import { Flag } from '../node';
-import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isNonblankFirstLine, blankWith } from '../visibility';
@@ -20,58 +20,57 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
-  union([
-    surround(
-      // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[ >])/y),
-      precedence(9, some(union([attribute]))),
-      open(str(/ ?/y), str('>'), true),
-      true, [],
-      ([as, bs = new List(), cs], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
-      ([as, bs = new List()], context) =>
-        new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
-    match(
-      new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
-      memoize(
-      ([, tag]) =>
-        surround<HTMLParser.TagParser, string>(
-          surround(
-            str(`<${tag}`),
-            precedence(9, some(attribute)),
-            open(str(/ ?/y), str('>'), true),
-            true, [],
-            ([as, bs = new List(), cs]) => as.import(bs).import(cs),
-            ([as, bs = new List()]) => as.import(bs)),
-          // 不可視のHTML構造が可視構造を変化させるべきでない。
-          // 可視のHTMLは優先度変更を検討する。
-          // このため`<>`記号は将来的に共通構造を変化させる可能性があり
-          // 共通構造を変化させない非構造文字列としては依然としてエスケープを要する。
-          precedence(0, recursion(Recursion.inline,
-          some(union([
-            some(inline, blankWith('\n', `</${tag}>`)),
-            open('\n', some(inline, `</${tag}>`), true),
-          ])))),
-          str(`</${tag}>`),
+export const html: HTMLParser = lazy(() => union([
+  surround(
+    // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+    str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[ >])/y),
+    precedence(9, some(union([attribute]))),
+    open(str(/ ?/y), str('>'), true),
+    true, [],
+    ([as, bs = new List(), cs], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context), as.head!.value === '<wbr' ? Flag.blank : Flag.none)]),
+    ([as, bs = new List()], context) =>
+      new List([new Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+  match(
+    new RegExp(String.raw`<(${TAGS.join('|')})(?=[ >])`, 'y'),
+    memoize(
+    ([, tag]) =>
+      surround<HTMLParser.TagParser, string>(
+        surround(
+          str(`<${tag}`),
+          precedence(9, some(attribute)),
+          open(str(/ ?/y), str('>'), true),
           true, [],
-          ([as, bs = new List(), cs], context) =>
-            new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
-          ([as, bs = new List()], context) =>
-            new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
-      ([, tag]) => tag,
-      new Map())),
-    surround(
-      // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<[a-z]+(?=[ >])/yi),
-      precedence(9, some(union([attribute]))),
-      open(str(/ ?/y), str('>'), true),
-      true, [],
-      ([as, bs = new List(), cs], context) =>
-        new List([new Node(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 Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
-  ])));
+          ([as, bs = new List(), cs]) => as.import(bs).import(cs),
+          ([as, bs = new List()]) => as.import(bs)),
+        // 不可視のHTML構造が可視構造を変化させるべきでない。
+        // 可視のHTMLは優先度変更を検討する。
+        // このため`<>`記号は将来的に共通構造を変化させる可能性があり
+        // 共通構造を変化させない非構造文字列としては依然としてエスケープを要する。
+        precedence(0, recursion(Recursion.inline,
+        some(union([
+          some(inline, blankWith('\n', `</${tag}>`)),
+          open('\n', some(inline, `</${tag}>`), true),
+        ])))),
+        str(`</${tag}>`),
+        true, [],
+        ([as, bs = new List(), cs], context) =>
+          new List([new Node(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
+        ([as, bs = new List()], context) =>
+          new List([new Node(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
+    ([, tag]) => tag2index(tag),
+    Array(TAGS.length))),
+  surround(
+    // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+    str(/<[a-z]+(?=[ >])/yi),
+    precedence(9, some(union([attribute]))),
+    open(str(/ ?/y), str('>'), true),
+    true, [],
+    ([as, bs = new List(), cs], context) =>
+      new List([new Node(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 Node(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
+]));
 
 export const attribute: HTMLParser.AttributeParser = union([
   str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ >])/yi),
@@ -146,7 +145,7 @@ export function attributes(
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
 // [...document.querySelectorAll('tbody > tr > td:first-child')].map(el => el.textContent.slice(1, -1))
-const TAGS: readonly string[] = [
+export const TAGS: readonly string[] = [
   "html",
   "base",
   "head",
@@ -284,3 +283,12 @@ const TAGS: readonly string[] = [
   "tt",
   "xmp",
 ];
+
+const tag2index: (tag: string) => number = eval([
+  'tag => {',
+  'switch(tag){',
+  TAGS.map((tag, i) => `case '${tag}':return ${i};`).join(''),
+  'default: throw new Error();',
+  '}',
+  '}',
+].join(''));

package/src/parser/inline.ts

@@ -92,7 +92,8 @@ export const inline: InlineParser = lazy(() => union([
       case '｛':
         return bracket(input);
       case '<':
-        return html(input);
+        if (isAlphabet(source[position + 1])) return html(input);
+        break;
       case '$':
         if (source[position + 1] === '{') return math(input);
         return label(input)
@@ -131,3 +132,8 @@ export { dataindex } from './inline/extension/index';
 export { medialink } from './inline/link';
 export { media } from './inline/media';
 export { shortmedia, lineshortmedia } from './inline/shortmedia';
+
+function isAlphabet(char: string): boolean {
+  assert(char.length === 1);
+  return 'a' <= char && char <= 'z';
+}

package/src/parser/processor/note.ts

@@ -226,7 +226,7 @@ function build(
         splitter.remove();
       }
     }
-  }
+  };
 }
 
 function* proc(note: HTMLOListElement, defs?: Map<string, HTMLLIElement>): Generator<HTMLLIElement | undefined, undefined, undefined> {

package/src/parser/segment.ts

@@ -6,6 +6,7 @@ import { segment as codeblock } from './block/codeblock';
 import { segment as mathblock } from './block/mathblock';
 import { segment as extension } from './block/extension';
 import { contentline, emptysegment } from './source';
+import { normalize } from './api';
 
 import SegmentParser = MarkdownParser.SegmentParser;
 
@@ -37,8 +38,8 @@ const parser: SegmentParser = union([
   some(contentline, MAX_SEGMENT_SIZE + 1),
 ]);
 
-export function* segment(source: string): Generator<readonly [string, Segment], undefined, undefined> {
-  if (!validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
+export function* segment(source: string, initial = true): Generator<readonly [string, Segment], undefined, undefined> {
+  if (initial && !validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
   assert(source.length < Number.MAX_SAFE_INTEGER);
   for (let position = 0; position < source.length;) {
     const context = new Context({ source, position });
@@ -52,14 +53,14 @@ export function* segment(source: string): Generator<readonly [string, Segment],
     position = context.position;
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
-      validate(seg, MAX_SEGMENT_SIZE)
-        ? yield [seg, context.segment]
-        : yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown];
+      initial && !validate(seg, MAX_SEGMENT_SIZE)
+        ? yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown]
+        : yield [initial ? normalize(seg) : seg, context.segment];
     }
   }
 }
 
 export function validate(source: string, size: number): boolean {
-  return source.length <= size / 4
+  return source.length <= size / 2
       || source.length <= size && new Blob([source]).size <= size;
 }

package/src/parser/source/escapable.ts

@@ -31,7 +31,6 @@ export const escsource: EscapableSourceParser = context => {
           return new List([new Node(source.slice(position, position + 2))]);
       }
     case '\r':
-      consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;

package/src/parser/source/line.ts

@@ -10,7 +10,7 @@ export const anyline: AnyLineParser = input => {
   return new List();
 };
 
-const regEmptyline = /[^\S\n]*(?:$|\n)/y;
+const regEmptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
 export const emptyline: EmptyLineParser = input => {
   const context = input;
   const { source, position } = context;
@@ -36,18 +36,20 @@ export const emptysegment: EmptySegmentParser = input => {
   return new List();
 };
 function eoel(source: string, position: number): number {
-  if (source[position] === '\n') return position + 1;
+  const char = source[position];
+  if (char === '\n' || char === '\r' && source[position + 1] === '\n') return position + 1;
   regEmptyline.lastIndex = position;
   regEmptyline.test(source);
   return regEmptyline.lastIndex || position;
 }
 
-const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
+const regContentline = /[^\S\r\n]*\S[^\r\n]*(?:$|\r?\n)/y;
 export const contentline: ContentLineParser = input => {
   const context = input;
   const { source, position } = context;
   if (position === source.length) return;
-  if (source[position] === '\n') return;
+  const char = source[position];
+  if (char === '\n' || char === '\r' && source[position + 1] === '\n') return;
   regContentline.lastIndex = position;
   regContentline.test(source);
   const i = regContentline.lastIndex;

package/src/parser/source/text.ts

@@ -29,7 +29,6 @@ export const text: TextParser = input => {
           return new List([new Node(source.slice(position + 1, context.position))]);
       }
     case '\r':
-      consume(-1, context);
       return new List();
     case '\n':
       context.linebreak ||= source.length - position;
@@ -178,8 +177,8 @@ export function isAlphanumeric(char: string): boolean {
 
 function seek(source: string, position: number, state: number): number {
   for (let i = position + 1; i < source.length; ++i) {
-    const fst = source[i];
-    switch (fst) {
+    const char = source[i];
+    switch (char) {
       case '\\':
       case '!':
       case '$':
@@ -211,10 +210,10 @@ function seek(source: string, position: number, state: number): number {
       case '+':
       case '~':
       case '=':
-        if (source[i + 1] === fst) return i;
+        if (source[i + 1] === char) return i;
         continue;
       case '/':
-        if (source[i + 1] === fst && source[i + 2] === fst) return i;
+        if (source[i + 1] === char && source[i + 2] === char) return i;
         continue;
       case '%':
         if (source[i + 1] === ']' && isWhitespace(source[i - 1], true)) return i;