securemark 0.283.3 → 0.283.5

package/src/parser/inline/mark.ts

@@ -1,10 +1,10 @@
 import { MarkParser } from '../inline';
+import { State, Recursion } from '../context';
 import { union, some, syntax, creation, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { State, Recursion } from '../context';
 import { unshift } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 

package/src/parser/inline/math.ts

@@ -1,7 +1,7 @@
 import { MathParser } from '../inline';
+import { Recursion } from '../context';
 import { union, some, creation, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
 import { escsource, unescsource, str } from '../source';
-import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;

package/src/parser/inline/media.ts

@@ -1,10 +1,10 @@
 import { MediaParser } from '../inline';
+import { State, Recursion, Backtrack, Command, CmdRegExp } from '../context';
 import { union, inits, tails, some, syntax, creation, precedence, constraint, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { unsafelink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, linebreak, str } from '../source';
-import { State, Recursion, Backtrack } from '../context';
 import { markInvalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
@@ -25,7 +25,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(1,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
-      some(union([unsafehtmlentity, bracket, txt]), ']', [[/^\\?\n/, 9]]),
+      some(union([unsafehtmlentity, bracket, txt]), ']', [['\n', 9]]),
       ']',
       true, undefined, undefined, 1 | Backtrack.media)),
     dup(surround(
@@ -105,8 +105,8 @@ function sanitize(target: HTMLElement, uri: ReadonlyURL, alt: string): boolean {
       markInvalid(target, 'media', 'argument', 'Invalid protocol');
       return false;
   }
-  if (alt.includes('\x1B')) {
-    define(target, { alt: target.getAttribute('alt')?.replace(/\x1B/g, '') });
+  if (alt.includes(Command.Escape)) {
+    define(target, { alt: target.getAttribute('alt')?.replace(CmdRegExp.Escape, '') });
     markInvalid(target, 'media', 'content',
       `Cannot use invalid HTML entitiy "${alt.match(/&[0-9A-Za-z]+;/)![0]}"`);
     return false;

package/src/parser/inline/reference.ts

@@ -1,9 +1,9 @@
 import { ReferenceParser } from '../inline';
+import { State, Recursion, Backtrack } from '../context';
 import { union, subsequence, some, syntax, creation, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { State, Recursion, Backtrack } from '../context';
-import { blank, trimBlankStart, trimNodeEnd } from '../visibility';
+import { blank, trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
 export const reference: ReferenceParser = lazy(() => creation(1, Recursion.ignore, surround(
@@ -12,11 +12,14 @@ export const reference: ReferenceParser = lazy(() => creation(1, Recursion.ignor
   syntax(1, State.annotation | State.reference | State.media,
   subsequence([
     abbr,
-    trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 1]])),
+    trimBlankStart(some(inline, ']', [['\n', 9], [']', 1]])),
   ]))),
   ']]',
   false,
-  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest],
+  ([, ns], rest) =>
+    trimBlankNodeEnd(ns).length > 0
+      ? [[html('sup', attributes(ns), [html('span', defrag(ns))])], rest]
+      : undefined,
   undefined, 1 | Backtrack.bracket)));
 
 // Chicago-Style

package/src/parser/inline/remark.ts

@@ -1,19 +1,19 @@
 import { RemarkParser } from '../inline';
+import { State, Recursion } from '../context';
 import { union, some, syntax, creation, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { State, Recursion } from '../context';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, syntax(4, State.none, match(
+export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recursion.inline, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>
     surround(
       open(str(`[${fence}`), some(text, new RegExp(String.raw`^\s+${fence}\]|^\S`)), true),
-      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]]),
+      syntax(4, State.none, some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]])),
       close(some(text, /^\S/), str(`${fence}]`)), true,
       ([as, bs = [], cs], rest) => [[
         html('span', { class: 'remark' }, [
@@ -22,4 +22,4 @@ export const remark: RemarkParser = lazy(() => validate('[%', creation(1, Recurs
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, {}))))));
+  ([, fence]) => fence.length, {})))));

package/src/parser/inline/ruby.ts

@@ -1,14 +1,15 @@
 import { RubyParser } from '../inline';
+import { State, Recursion, Backtrack, Command, CmdRegExp } from '../context';
 import { eval, exec } from '../../combinator/data/parser';
 import { sequence, syntax, creation, validate, surround, lazy, fmap, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt, str } from '../source';
-import { State, Recursion, Backtrack } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, syntax(1, State.all, fmap(
+export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.ignore, fmap(
+  syntax(1, State.all,
   sequence([
     bind(surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']', false, undefined, undefined, 3 | Backtrack.ruby), ([source], rest, context) => {
       const ns = eval(text({ source, context }), [undefined])[0];
@@ -19,7 +20,7 @@ export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.i
       const ns = eval(text({ source, context }), [undefined])[0];
       return ns && [[ns], rest];
     }),
-  ]),
+  ])),
   ([texts, rubies]) => {
     switch (true) {
       case rubies.length <= texts.length:
@@ -50,7 +51,7 @@ export const ruby: RubyParser = lazy(() => validate('[', creation(1, Recursion.i
             [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
         ];
     }
-  })))));
+  }))));
 
 const text: RubyParser.TextParser = creation(1, Recursion.ignore, ({ source, context }) => {
   const acc = [''];
@@ -90,8 +91,8 @@ function attributes(texts: string[], rubies: string[]): Record<string, string> {
   let attrs: Record<string, string> | undefined;
   for (const ss of [texts, rubies]) {
     for (let i = 0; i < ss.length; ++i) {
-      if (!ss[i].includes('\x1B')) continue;
-      ss[i] = ss[i].replace(/\x1B/g, '');
+      if (!ss[i].includes(Command.Escape)) continue;
+      ss[i] = ss[i].replace(CmdRegExp.Escape, '');
       attrs ??= {
         class: 'invalid',
         'data-invalid-syntax': 'ruby',

package/src/parser/inline/shortmedia.ts

@@ -1,9 +1,9 @@
 import { ShortMediaParser } from '../inline';
+import { State } from '../context';
 import { union, constraint, focus, rewrite, open, convert } from '../../combinator';
 import { url } from './autolink/url';
 import { media } from './media';
 import { linebreak } from '../source';
-import { State } from '../context';
 
 export const shortmedia: ShortMediaParser = rewrite(
   constraint(State.media, false,

package/src/parser/inline/strong.ts

@@ -1,9 +1,9 @@
 import { StrongParser } from '../inline';
+import { State, Recursion } from '../context';
 import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { State, Recursion } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';

package/src/parser/inline/template.ts

@@ -1,7 +1,7 @@
 import { TemplateParser } from '../inline';
+import { State, Recursion, Backtrack } from '../context';
 import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { State, Recursion, Backtrack } from '../context';
 import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
@@ -10,7 +10,7 @@ export const template: TemplateParser = lazy(() => creation(1, Recursion.ignore,
   syntax(1, State.all, some(union([bracket, escsource]), '}')),
   '}}',
   true,
-  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
+  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('')}}}`)], rest],
   undefined, 3 | Backtrack.template)));
 
 const bracket: TemplateParser.BracketParser = lazy(() => creation(0, Recursion.terminal, union([

package/src/parser/inline.test.ts

@@ -173,6 +173,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('"{{""}}')), [['"', '{', '{', '"', '"', '}', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('[#http://a/(<bdi>)]</bdi>')), [['<a class="index" href="#index::http://a/(&lt;bdi&gt;)">http://a/(&lt;bdi&gt;)</a>', '<', '/', 'bdi', '>'], '']);
     });
 
     it('uri', () => {

package/src/parser/segment.ts

@@ -1,4 +1,5 @@
 import { MarkdownParser } from '../../markdown';
+import { Command } from './context';
 import { eval, exec } from '../combinator/data/parser';
 import { union, some } from '../combinator';
 import { segment as heading } from './block/heading';
@@ -22,7 +23,7 @@ const parser: SegmentParser = union([
 ]);
 
 export function* segment(source: string): Generator<string, undefined, undefined> {
-  if (!validate(source, MAX_INPUT_SIZE)) return yield `\x07Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;
+  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)}`;
   assert(source.length < Number.MAX_SAFE_INTEGER);
   while (source !== '') {
     const result = parser({ source, context: {} })!;
@@ -35,7 +36,7 @@ export function* segment(source: string): Generator<string, undefined, undefined
       const seg = segs[i];
       validate(seg, MAX_SEGMENT_SIZE)
         ? yield seg
-        : yield `\x07Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`
+        : yield `${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`
     }
     source = rest;
   }

package/src/parser/source/escapable.ts

@@ -1,7 +1,7 @@
 import { EscapableSourceParser } from '../source';
+import { Recursion, Command } from '../context';
 import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
-import { Recursion } from '../context';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
@@ -17,7 +17,7 @@ export const escsource: EscapableSourceParser = creation(1, Recursion.ignore, ({
           assert(!source.includes('\r', 1));
           context.resources && ++context.resources.clock;
           return [[], source.slice(1)];
-        case '\x1B':
+        case Command.Escape:
           return [[source.slice(1, 2)], source.slice(2)];
         case '\\':
           switch (source[1]) {

package/src/parser/source/str.ts

@@ -1,7 +1,7 @@
 import { StrParser } from '../source';
+import { Recursion } from '../context';
 import { Parser, Context } from '../../combinator/data/parser';
 import { creation } from '../../combinator';
-import { Recursion } from '../context';
 
 export function str(pattern: string | RegExp, not?: string): StrParser;
 export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {

package/src/parser/source/text.ts

@@ -1,7 +1,7 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
+import { Recursion, Command } from '../context';
 import { union, creation, focus } from '../../combinator';
 import { str } from './str';
-import { Recursion } from '../context';
 import { html } from 'typed-dom/dom';
 
 export const delimiter = /[\s\x00-\x7F（）［］｛｝“”‘’「」『』]|\S[#>]/u;
@@ -21,12 +21,12 @@ export const text: TextParser = creation(1, Recursion.ignore, ({ source, context
           assert(!source.includes('\r', 1));
           context.resources && ++context.resources.clock;
           return [[], source.slice(1)];
-        case '\x1B':
+        case Command.Escape:
         case '\\':
           switch (source[1]) {
             case undefined:
             case '\n':
-              assert(source[0] !== '\x1B');
+              assert(source[0] !== Command.Escape);
               return [[], source.slice(1)];
             default:
               return [[source.slice(1, 2)], source.slice(2)];

package/src/parser/source/unescapable.ts

@@ -1,10 +1,9 @@
 import { UnescapableSourceParser } from '../source';
+import { Recursion, Command } from '../context';
 import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
-import { Recursion } from '../context';
 
 export const unescsource: UnescapableSourceParser = creation(1, Recursion.ignore, ({ source, context }) => {
-  assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {
@@ -16,6 +15,9 @@ export const unescsource: UnescapableSourceParser = creation(1, Recursion.ignore
           assert(!source.includes('\r', 1));
           context.resources && ++context.resources.clock;
           return [[], source.slice(1)];
+        case Command.Escape:
+          assert(source[0] !== Command.Escape);
+          return [[source.slice(1, 2)], source.slice(2)];
       }
       const b = source[0] !== '\n' && source[0].trimStart() === '';
       const i = b || isAlphanumeric(source[0])

package/src/parser/visibility.ts

@@ -1,4 +1,5 @@
 import { MarkdownParser } from '../../markdown';
+import { Command } from './context';
 import { Parser, Input, eval } from '../combinator/data/parser';
 import { union, some, verify, convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
@@ -21,7 +22,7 @@ export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
   return union([
     convert(
-      source => source.replace(blank.line, line => line.replace(/[\\&<]/g, '\x1B$&')),
+      source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
       verify(parser, (ns, rest) => !rest && hasVisible(ns))),
     some(union([linebreak, unescsource])),
   ]);
@@ -64,7 +65,7 @@ export function blankWith(starting: '' | '\n', delimiter?: string | RegExp): Reg
 //}
 //const isStartLoose = reduce(({ source, context }: Input<MarkdownParser.Context>, except?: string): boolean => {
 //  return isStartTight({ source: source.replace(blank.start, ''), context }, except);
-//}, ({ source }, except = '') => `${source}\x1E${except}`);
+//}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
 
 export function startTight<P extends Parser<unknown>>(parser: P, except?: string): P;
 export function startTight<T>(parser: Parser<T>, except?: string): Parser<T> {
@@ -103,7 +104,7 @@ const isStartTight = reduce(({ source, context }: Input<MarkdownParser.Context>,
     default:
       return source[0].trimStart() !== '';
   }
-}, ({ source }, except = '') => `${source}\x1E${except}`);
+}, ({ source }, except = '') => `${source}${Command.Separator}${except}`);
 
 export function isStartLooseNodes(nodes: readonly (HTMLElement | string)[]): boolean {
   if (nodes.length === 0) return true;
@@ -159,16 +160,16 @@ export function trimBlankStart<T>(parser: Parser<T>): Parser<T> {
     source => source.replace(blank.start, ''),
     parser);
 }
-function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
-function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser<T> {
+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);
+    trimBlankNodeEnd);
 }
-//export function trimNode<T extends HTMLElement | string>(nodes: T[]): T[] {
-//  return trimNodeStart(trimNodeEnd(nodes));
+//export function trimBlankNode<T extends HTMLElement | string>(nodes: T[]): T[] {
+//  return trimBlankNodeStart(trimBlankNodeEnd(nodes));
 //}
-//function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
+//function trimBlankNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
 //  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
 //    if (typeof node === 'string') {
 //      const pos = node.trimStart().length;
@@ -184,7 +185,7 @@ function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser
 //  }
 //  return nodes;
 //}
-export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
+export function trimBlankNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
   const skip = nodes.length > 0 &&
     typeof nodes.at(-1) === 'object' &&
     nodes.at(-1)!['className'] === 'indexer'
@@ -192,9 +193,9 @@ export function trimNodeEnd<T extends HTMLElement | string>(nodes: T[]): T[] {
     : [];
   for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes.at(-1)!, -1);) {
     if (typeof node === 'string') {
-      const pos = node.trimEnd().length;
-      if (pos > 0) {
-        nodes[nodes.length - 1] = node.slice(0, pos) as T;
+      const len = node.trimEnd().length;
+      if (len > 0) {
+        nodes[nodes.length - 1] = node.slice(0, len) as T;
         break;
       }
     }