securemark 0.296.2 → 0.296.4

package/src/combinator/control/constraint/block.ts

@@ -1,19 +1,25 @@
-import { Parser, failsafe } from '../../data/parser';
+import { Parser, List, Segment, failsafe } from '../../data/parser';
 import { isEmptyline } from './line';
 
-export function block<P extends Parser>(parser: P, separation?: boolean): P;
-export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
+export function block<P extends Parser>(parser: P, separation?: boolean, segment?: number): P;
+export function block<N>(parser: Parser<N>, separation = true, segment = 0): Parser<N> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
     if (position === source.length) return;
+    if (segment !== 0 && context.segment & Segment.write) {
+      if (context.segment !== (segment | Segment.write)) return;
+      context.position = source.length;
+      return new List();
+    }
     const result = parser(input);
     if (result === undefined) return;
     if (separation && !isEmptyline(source, context.position)) return;
     assert(context.position === source.length || source[context.position - 1] === '\n');
-    return context.position === source.length || source[context.position - 1] === '\n'
-      ? result
-      : undefined;
+    if (segment !== 0 && context.segment & Segment.write ^ Segment.write) {
+      context.segment = segment;
+    }
+    return result;
   });
 }

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

@@ -1,7 +1,7 @@
 import { Parser, Input, Result, Context } from '../../data/parser';
 
-export function recover<P extends Parser>(parser: P, fallback: (input: Input<Parser.Context<P>>, reason: unknown) => Result<Parser.Node<P>>): P;
-export function recover<N>(parser: Parser<N>, fallback: (input: Input<Context>, reason: unknown) => Result<N>): Parser<N> {
+export function recover<P extends Parser>(parser: P, catcher: (input: Input<Parser.Context<P>>, reason: unknown) => Result<Parser.Node<P>>): P;
+export function recover<N>(parser: Parser<N>, catcher: (input: Input<Context>, reason: unknown) => Result<N>): Parser<N> {
   return input => {
     const { context } = input;
     const { source, position } = context;
@@ -12,7 +12,7 @@ export function recover<N>(parser: Parser<N>, fallback: (input: Input<Context>,
       assert(reason instanceof Error && reason.name === 'AssertionError' && !+console.error(reason) || 1);
       context.source = source;
       context.position = position;
-      return fallback(input, reason);
+      return catcher(input, reason);
     }
   };
 }

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

@@ -103,7 +103,7 @@ export function surround<N>(
       const result = g?.([nodesO, nodesM], context);
       return result || void revert(context, linebreak);
     }
-    const nodesC = nodesM || optional ? closer(input) : undefined;
+    const nodesC = optional || nodesM ? closer(input) : undefined;
     context.range = context.position - position;
     if (nodesC === undefined) {
       wbs && setBacktrack(context, wbs, position);

package/src/combinator/data/parser/context.test.ts

@@ -21,9 +21,9 @@ describe('Unit: combinator/data/parser/context', () => {
       const ctx: Ctx = new Context();
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
-      assert(ctx.resources?.clock === undefined);
+      assert(ctx.resources?.clock === 0);
       assert.throws(() => reset(base, parser)(input('1234', ctx)));
-      assert(ctx.resources?.clock === undefined);
+      assert(ctx.resources?.clock === 0);
     });
 
     it('node', () => {

package/src/combinator/data/parser/context.ts

@@ -4,13 +4,22 @@ import { clone } from 'spica/assign';
 
 export function reset<P extends Parser>(base: Options, parser: P): P;
 export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
+  return input => {
+    const { context } = input;
+    // @ts-expect-error
+    context.resources ??= {
+      clock: base.resources?.clock,
+      recursions: base.resources?.recursions.slice(),
+    };
+    context.backtracks = {};
+    return parser(input);
+  };
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
   const values = Array(changes.length);
   return ({ context }) =>
-    // 大域離脱時の汚染回避のため複製
-    apply(parser, { ...context }, changes, values, true);
+    apply(parser, context, changes, values, true);
 }
 
 export function context<P extends Parser>(base: Options, parser: P): P;

package/src/combinator/data/parser.ts

@@ -33,6 +33,7 @@ export class Context {
     {
       source,
       position,
+      segment,
       resources,
       delimiters,
       precedence,
@@ -45,6 +46,7 @@ export class Context {
   ) {
     this.source = source ?? '';
     this.position = position ?? 0;
+    this.segment = segment ?? 0;
     this.resources = resources;
     this.precedence = precedence ?? 0;
     this.delimiters = delimiters ?? new Delimiters();
@@ -56,6 +58,7 @@ export class Context {
   }
   public source: string;
   public position: number;
+  public segment: number;
   public readonly resources?: {
     clock: number;
     recursions: number[];
@@ -103,6 +106,10 @@ export class Context {
   public backtracks: Record<number, number>;
 }
 export type Options = Partial<Context>;
+export const enum Segment {
+  unknown = 0,
+  write = 1,
+}
 
 export function input<C extends Context>(source: string, context: C): Input<C> {
   context.source = source;

package/src/parser/api/bind.ts

@@ -1,5 +1,5 @@
 import { ParserSettings, Progress } from '../../..';
-import { Context } from '../context';
+import { Context, Segment } from '../context';
 import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
 import { block } from '../block';
@@ -8,7 +8,7 @@ import { headers } from './header';
 import { figure } from '../processor/figure';
 import { note } from '../processor/note';
 import { ReadonlyURL } from 'spica/url';
-import { push, splice } from 'spica/array';
+import { splice } from 'spica/array';
 
 interface Settings extends ParserSettings {
 }
@@ -29,8 +29,8 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   type Block = readonly [segment: string, blocks: readonly HTMLElement[], url: string];
   const blocks: Block[] = [];
-  const adds: [HTMLElement, Node | null][] = [];
-  const dels: [HTMLElement][] = [];
+  const adds: (readonly [HTMLElement, Node | null])[] = [];
+  const dels: (readonly [HTMLElement])[] = [];
   const bottom = target.firstChild;
   let revision: symbol | undefined;
   return {
@@ -47,8 +47,10 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     context.url = url ? new ReadonlyURL(url as ':') : undefined;
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
-    for (const seg of segment(source)) {
+    const sourceSegmentAttrs: Segment[] = [];
+    for (const [seg, attr] of segment(source)) {
       sourceSegments.push(seg);
+      sourceSegmentAttrs.push(attr);
       yield { type: 'segment', value: seg };
     }
     const targetSegments = blocks.map(([seg]) => seg);
@@ -74,16 +76,19 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     context.header = true;
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
-      const seg = sourceSegments[index];
-      const es = block(input(seg, context))
+      const src = sourceSegments[index];
+      context.segment = sourceSegmentAttrs[index] | Segment.write;
+      const es = block(input(src, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
       // @ts-expect-error
       context.header = false;
-      blocks.splice(index, 0, [seg, es, url]);
+      blocks.length === index
+        ? blocks.push([src, es, url])
+        : blocks.splice(index, 0, [src, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.
-      push(adds, es.map(el => [el, base] as const));
+      adds.push(...es.map(el => [el, base] as const));
       adds.reverse();
       for (; adds.length > 0;) {
         assert(rev === revision);
@@ -98,7 +103,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       assert(rev === revision);
       const es = refuse[i][1];
       if (es.length === 0) continue;
-      push(dels, es.map(el => [el]));
+      dels.push(...es.map(el => [el] as const));
     }
     assert(blocks.length === sourceSegments.length);
     adds.reverse();

package/src/parser/api/parse.ts

@@ -1,6 +1,6 @@
 import { ParserOptions } from '../../..';
 import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { Context, Segment } from '../context';
 import { segment } from '../segment';
 import { block } from '../block';
 import { normalize } from './normalize';
@@ -32,9 +32,10 @@ export function parse(source: string, options: Options = {}, context?: Context):
   const node = frag();
   // @ts-expect-error
   context.header = true;
-  for (const seg of segment(source)) {
+  for (const [seg, attr] of segment(source)) {
+    context.segment = attr | Segment.write;
     node.append(
-      ...block(input(seg, context))
+      ...block(input(seg, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
     // @ts-expect-error
     context.header = false;

package/src/parser/block/extension/fig.ts

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../block';
+import { Segment } from '../../context';
 import { union, sequence, some, block, line, verify, rewrite, close, convert } from '../../../combinator';
 import { contentline } from '../../source';
 import { figure } from './figure';
@@ -23,7 +24,7 @@ export const segment: FigParser.SegmentParser = block(
       seg_placeholder,
       some(contentline),
     ]),
-  ]));
+  ]), true, Segment.fig);
 
 export const fig: FigParser = block(rewrite(segment, verify(convert(
   (source, context) => {
@@ -33,6 +34,7 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
     const { position } = context;
     const result = parser({ context });
     context.position = position;
+    context.segment = Segment.figure | Segment.write;
     return result
       ? `${fence}figure ${source.replace(/^(.+\n.+\n)([\S\s]+?)\n?$/, '$1\n$2')}\n${fence}`
       : `${fence}figure ${source}\n\n${fence}`;

package/src/parser/block/extension/figure.ts

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../block';
+import { Segment } from '../../context';
 import { List, Node, subinput } from '../../../combinator/data/parser';
 import { union, inits, sequence, some, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
@@ -44,7 +45,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length - 1, [], 2 ** 4 - 1)));
+  ([, fence]) => fence.length - 1, [], 2 ** 4 - 1)), true, Segment.figure);
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),

package/src/parser/block/extension/message.ts

@@ -57,7 +57,7 @@ export const message: MessageParser = block(fmap(
           'data-type': type,
         },
         [...segment(body)].reduce(
-          (acc, seg) =>
+          (acc, [seg]) =>
             push(acc, unwrap(content(subinput(seg, context)))),
           [html('h1', title(type))])))
     ]);

package/src/parser/block/extension.test.ts

@@ -30,9 +30,9 @@ describe('Unit: parser/block/extension', () => {
       assert(parser(input('~~~\na\n~~~', new Context())));
       assert(parser(input('~~~a\n~~~', new Context())));
       assert(parser(input('~~~a\nb\n~~~', new Context())));
-      assert(parser(input('$-0', new Context())));
-      assert(parser(input('$-0\n', new Context())));
-      assert(parser(input('$-0\n\n', new Context())));
+      //assert(parser(input('$-0', new Context())));
+      //assert(parser(input('$-0\n', new Context())));
+      //assert(parser(input('$-0\n\n', new Context())));
     });
 
   });

package/src/parser/block/extension.ts

@@ -1,7 +1,6 @@
 import { ExtensionParser } from '../block';
 import { union } from '../../combinator';
-import { figbase } from './extension/figbase';
-import { fig, segment as seg_fig } from './extension/fig';
+import { segment as seg_fig } from './extension/fig';
 import { figure, segment as seg_figure } from './extension/figure';
 import { table, segment as seg_table } from './extension/table';
 import { message } from './extension/message';
@@ -17,8 +16,8 @@ export const segment: ExtensionParser.SegmentParser = union([
 ]);
 
 export const extension: ExtensionParser = union([
-  figbase,
-  fig,
+  //figbase,
+  //fig,
   figure,
   table,
   message,

package/src/parser/block/heading.ts

@@ -1,9 +1,9 @@
 import { HeadingParser } from '../block';
-import { State } from '../context';
+import { Segment, State } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, state, block, line, focus, rewrite, open, fmap, firstline } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
-import { str } from '../source';
+import { str, strs } from '../source';
 import { visualize, trimBlank } from '../visibility';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
@@ -20,14 +20,14 @@ export const segment: HeadingParser.SegmentParser = block(focus(
       context.position += line.length;
     }
     return acc;
-  }, false));
+  }, false), true, Segment.heading);
 
 export const heading: HeadingParser = block(rewrite(segment,
   // その他の表示制御は各所のCSSで行う。
   state(State.annotation | State.reference | State.index | State.label | State.link,
   line(indexee(fmap(union([
     open(
-      str(/##+/y),
+      strs('#', 2),
       visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),

package/src/parser/block.ts

@@ -1,10 +1,10 @@
 import { MarkdownParser } from '../../markdown';
-import { Recursion, Command } from './context';
+import { Segment, Recursion, Command } from './context';
 import { List, Node } from '../combinator/data/parser';
-import { union, reset, open, fallback, recover } from '../combinator';
+import { union, reset, firstline, recover } from '../combinator';
 import { MAX_SEGMENT_SIZE } from './segment';
 import { header } from './header';
-import { emptyline } from './source';
+import { emptysegment } from './source';
 import { pagebreak } from './block/pagebreak';
 import { heading } from './block/heading';
 import { ulist } from './block/ulist';
@@ -15,6 +15,9 @@ import { table } from './block/table';
 import { codeblock } from './block/codeblock';
 import { mathblock } from './block/mathblock';
 import { extension } from './block/extension';
+import { figbase } from './block/extension/figbase';
+import { fig } from './block/extension/fig';
+import { figure } from './block/extension/figure';
 import { sidefence } from './block/sidefence';
 import { blockquote } from './block/blockquote';
 import { mediablock } from './block/mediablock';
@@ -57,12 +60,22 @@ export const block: BlockParser = reset(
     backtracks: {},
   },
   error(union([
-    emptyline,
+    emptysegment,
     input => {
-      const { context: { source, position } } = input;
+      const { context: { source, position, segment } } = input;
       if (position === source.length) return;
+      switch (segment ^ Segment.write) {
+        case Segment.heading:
+          return heading(input);
+        case Segment.fig:
+          return fig(input);
+        case Segment.figure:
+          return figure(input);
+      }
       const fst = source[position];
       switch (fst) {
+        case Command.Error:
+          throw new Error(firstline(source, position + 1).trimEnd());
         case '=':
           if (source.startsWith('===', position)) return pagebreak(input);
           break;
@@ -84,7 +97,7 @@ export const block: BlockParser = reset(
         case '[':
           switch (source[position + 1]) {
             case '$':
-              return extension(input);
+              return figbase(input);
             case '!':
               return mediablock(input);
           }
@@ -95,11 +108,9 @@ export const block: BlockParser = reset(
         case '>':
           if (source[position + 1] === '>') return blockquote(input) || reply(input);
           return blockquote(input);
-        case '#':
-          return heading(input);
         case '$':
           if (source[position + 1] === '$') return mathblock(input);
-          return extension(input);
+          return figbase(input);
         case '|':
           return table(input) || sidefence(input);
         case '(':
@@ -113,9 +124,8 @@ export const block: BlockParser = reset(
 
 function error(parser: BlockParser): BlockParser {
   const reg = new RegExp(String.raw`^${Command.Error}[^\n]*\n`)
-  return recover<BlockParser>(fallback(
-    open(Command.Error, ({ context: { source, position } }) => { throw new Error(source.slice(position).split('\n', 1)[0]); }),
-    parser),
+  return recover<BlockParser>(
+    parser,
     ({ context: { source, position, id } }, reason) => new List([
       new Node(html('h1',
         {

package/src/parser/context.ts

@@ -7,6 +7,7 @@ export class Context extends Ctx {
   ) {
     super(options);
     const {
+      segment,
       buffer,
       sequential,
       header,
@@ -15,6 +16,7 @@ export class Context extends Ctx {
       id,
       caches,
     } = options;
+    this.segment = segment ?? Segment.unknown;
     this.buffer = buffer ?? new List();
     this.sequential = sequential ?? false;
     this.header = header ?? true;
@@ -23,6 +25,7 @@ export class Context extends Ctx {
     this.id = id;
     this.caches = caches;
   }
+  public override segment: Segment;
   public buffer: List<Node<(string | HTMLElement)>>;
   public sequential: boolean;
   public readonly header: boolean;
@@ -37,6 +40,16 @@ export class Context extends Ctx {
 }
 export type Options = Partial<Context>;
 
+export const enum Segment {
+  unknown = 0,
+  write = 1,
+  nonempty = 0,
+  empty = 1 << 1,
+  heading = 3 << 1,
+  fig = 4 << 1,
+  figure = 5 << 1,
+}
+
 export const enum State {
   annotation = 1 << 7,
   reference = 1 << 6,

package/src/parser/inline/emstrong.ts

@@ -26,7 +26,7 @@ export const emstrong: EmStrongParser = lazy(() =>
   precedence(0, recursion(Recursion.inline, repeat('***', beforeNonblank, surround(
     '',
     some(union([some(inline, '*', afterNonblank)])),
-    strs('*', 3),
+    strs('*', 1, 3),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
       assert(cs.length === 1);