securemark 0.296.3 → 0.296.5

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/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';
@@ -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,12 +76,15 @@ 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, new Context(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.

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,7 +32,8 @@ 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, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);

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/autolink/account.ts

@@ -13,7 +13,7 @@ import { define } from 'typed-dom/dom';
 export const account: AutolinkParser.AccountParser = lazy(() => constraint(State.autolink, state(State.autolink,
   surround(
     surround(
-      /(?<![0-9a-z])@/yi,
+      /(?<![0-9a-z@#])@/yi,
       str(/[0-9a-z](?:[.-](?=[0-9a-z])|[0-9a-z]){0,254}\/|/yi),
       str(/[a-z][0-9a-z]*(?:[.-][0-9a-z]+)*(?![_.-]?[0-9a-z@]|>>|:\S)/yi),
       false,

package/src/parser/inline/autolink/anchor.ts

@@ -18,7 +18,7 @@ import { define } from 'typed-dom/dom';
 
 export const anchor: AutolinkParser.AnchorParser = lazy(() => constraint(State.autolink, state(State.autolink,
   surround(
-    /(?<![0-9a-z])>>/yi,
+    /(?<![0-9a-z@#])>>/yi,
     str(/[0-9a-z]+(?:-[0-9a-z]+)*(?![_.-]?[0-9a-z@#]|>>|:\S)/yi),
     '',
     false,

package/src/parser/inline/autolink/hashnum.ts

@@ -10,7 +10,7 @@ import { define } from 'typed-dom/dom';
 export const hashnum: AutolinkParser.HashnumParser = lazy(() => constraint(State.autolink, state(State.autolink,
   surround(
     new RegExp([
-      /(?<![^\p{C}\p{S}\p{P}\s]|emoji)#/yu.source,
+      /(?<![^\p{C}\p{S}\p{P}\s]|emoji|[@#])#/yu.source,
     ].join('|').replace(/emoji/g, emoji.source), 'yu'),
     str(new RegExp([
       /[0-9]{1,9}(?![_.-]?[0-9a-z@#]|>>|:\S|[^\p{C}\p{S}\p{P}\s]|emoji)/yu.source,

package/src/parser/inline/autolink/hashtag.ts

@@ -14,7 +14,7 @@ export const emoji = /\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presen
 export const hashtag: AutolinkParser.HashtagParser = lazy(() => constraint(State.autolink, state(State.autolink,
   surround(
     new RegExp([
-      /(?<![^\p{C}\p{S}\p{P}\s]|emoji)#/yu.source,
+      /(?<![^\p{C}\p{S}\p{P}\s]|emoji|[@#])#/yu.source,
     ].join('|').replace(/emoji/g, emoji.source), 'yu'),
     verify(
       str(new RegExp([

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);

package/src/parser/inline/extension/indexee.ts

@@ -33,7 +33,7 @@ export function identity(
     if (index === '' && text.tagName === 'LI') return undefined;
     return index
       ? `${type}:${id ?? ''}:${index}`
-      : identity(type, id, signature(text));
+      : identity(type, id, signature(text.cloneNode(true)));
   }
   text = text.trim();
   if (text === '') return undefined;
@@ -106,10 +106,10 @@ assert(baseR(~0 >>> 0, 36) === (~0 >>> 0).toString(36));
 assert(baseR(61, 62) === 'Z');
 assert(baseR(62, 62) === '10');
 
-export function signature(source: Element | DocumentFragment): string {
-  assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))') || source.nodeName === 'MARK');
-  const target = source.cloneNode(true) as typeof source;
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .label[data-label], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'),
+export function signature(target: Element | DocumentFragment): string {
+  assert(!target.parentNode);
+  assert(!target.querySelector('br:not(:has(+ :is(ul, ol)))') || target.nodeName === 'MARK');
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol, .label[data-label]'),
            len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
     switch (el.tagName) {
@@ -144,9 +144,9 @@ export function signature(source: Element | DocumentFragment): string {
   return target.textContent!.trim();
 }
 
-export function text(source: Element | DocumentFragment): string {
-  assert(!navigator.userAgent.includes('Chrome') || !source.querySelector('br:not(:has(+ :is(ul, ol)))'));
-  const target = source.cloneNode(true) as typeof source;
+export function text(target: Element | DocumentFragment): string {
+  assert(!target.parentNode);
+  assert(!target.querySelector('br:not(:has(+ :is(ul, ol)))'));
   for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'),
            len = es.length, i = 0; i < len; ++i) {
     const el = es[i];

package/src/parser/inline/mark.ts

@@ -19,7 +19,7 @@ export const mark: MarkParser = lazy(() =>
     (nodes, { id, state }, nest) => {
       const el = html('mark', defrag(unwrap(nodes)));
       if (state & State.linkers || nest) return new List([new Node(el)]);
-      define(el, { id: identity('mark', id, signature(el)) });
+      define(el, { id: identity('mark', id, signature(el.cloneNode(true))) });
       return el.id
         ? new List([new Node(el), new Node(html('a', { href: `#${el.id}` }))])
         : new List([new Node(el)]);

package/src/parser/inline.test.ts

@@ -228,7 +228,6 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser, input('#a', new Context())), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('#http://host', new Context())), [['#', 'http', '://host'], '']);
       assert.deepStrictEqual(inspect(parser, input('#a\nb\n#c\n[#d]', new Context())), [['<a class="hashtag" href="/hashtags/a">#a</a>', '<br>', 'b', '<br>', '<a class="hashtag" href="/hashtags/c">#c</a>', '<br>', '<a class="index" href="#index::d">d</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('##a', new Context())), [['#', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('_#a', new Context())), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser, input('_#a_', new Context())), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser, input('_#a_b', new Context())), [['_', '<a class="hashtag" href="/hashtags/a_b">#a_b</a>'], '']);

package/src/parser/processor/note.test.ts

@@ -255,18 +255,20 @@ describe('Unit: parser/processor/note', () => {
             ]).outerHTML,
           ]);
         assert.deepStrictEqual(
-          note.outerHTML,
-          html('ol', [
-            html('li', { id: 'reference::def:a_b' }, [
-              html('span', 'a b'),
-              html('sup', [html('a', { href: '#reference::ref:a_b:1' }, '^1')]),
-            ]),
-          ]).outerHTML);
+          [note.outerHTML],
+          [
+            html('ol', [
+              html('li', { id: 'reference::def:a_b' }, [
+                html('span', 'a b'),
+                html('sup', [html('a', { href: '#reference::ref:a_b:1' }, '^1')]),
+              ]),
+            ]).outerHTML,
+          ]);
       }
     });
 
     it('abbr', () => {
-      const target = parse('[[^A 1|b]][[^A 1]][[^A 1]]');
+      const target = parse('[[^A 1]][[^A 1|b]][[^A 1]]');
       const note = html('ol');
       for (let i = 0; i < 3; ++i) {
         [...reference(target, note)];
@@ -289,17 +291,19 @@ describe('Unit: parser/processor/note', () => {
             ]).outerHTML,
           ]);
         assert.deepStrictEqual(
-          note.outerHTML,
-          html('ol', [
-            html('li', { id: 'reference::def:A_1' }, [
-              html('span', 'b'),
-              html('sup', [
-                html('a', { href: '#reference::ref:A_1:1', title: 'b' }, '^1'),
-                html('a', { href: '#reference::ref:A_1:2' }, '^2'),
-                html('a', { href: '#reference::ref:A_1:3' }, '^3'),
-              ])
-            ]),
-          ]).outerHTML);
+          [note.outerHTML],
+          [
+            html('ol', [
+              html('li', { id: 'reference::def:A_1' }, [
+                html('span', 'b'),
+                html('sup', [
+                  html('a', { href: '#reference::ref:A_1:1' }, '^1'),
+                  html('a', { href: '#reference::ref:A_1:2', title: 'b' }, '^2'),
+                  html('a', { href: '#reference::ref:A_1:3' }, '^3'),
+                ])
+              ]),
+            ]).outerHTML,
+          ]);
       }
     });
 
@@ -336,16 +340,18 @@ describe('Unit: parser/processor/note', () => {
             ]).outerHTML,
           ]);
         assert.deepStrictEqual(
-          note.outerHTML,
-          html('ol', [
-            html('li', { id: 'reference::def:B' }, [
-              html('span', 'c'),
-              html('sup', [
-                html('a', { href: '#reference::ref:B:1', title: 'c' }, '^1'),
-                html('a', { href: '#reference::ref:B:2' }, '^2'),
-              ]),
-            ]),
-          ]).outerHTML);
+          [note.outerHTML],
+          [
+            html('ol', [
+              html('li', { id: 'reference::def:B' }, [
+                html('span', 'c'),
+                html('sup', [
+                  html('a', { href: '#reference::ref:B:1', title: 'c' }, '^1'),
+                  html('a', { href: '#reference::ref:B:2' }, '^2'),
+                ]),
+              ]),
+            ]).outerHTML,
+          ]);
         target.lastChild?.remove();
       }
     });