hermium 0.1.9 → 0.2.0

package/dist/web-server/_libs/mdast-util-from-markdown.mjs

@@ -1,717 +0,0 @@
-import { d as decodeNumericCharacterReference } from "./micromark-util-decode-numeric-character-reference+[...].mjs";
-import { d as decodeString } from "./micromark-util-decode-string.mjs";
-import { n as normalizeIdentifier } from "./micromark-util-normalize-identifier+[...].mjs";
-import { d as decodeNamedCharacterReference } from "./decode-named-character-reference+[...].mjs";
-import { p as postprocess, a as parse, b as preprocess } from "./micromark.mjs";
-import { s as stringifyPosition } from "./unist-util-stringify-position.mjs";
-import { t as toString } from "./mdast-util-to-string.mjs";
-const own = {}.hasOwnProperty;
-function fromMarkdown(value, encoding, options) {
-  if (encoding && typeof encoding === "object") {
-    options = encoding;
-    encoding = void 0;
-  }
-  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));
-}
-function compiler(options) {
-  const config = {
-    transforms: [],
-    canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
-    enter: {
-      autolink: opener(link),
-      autolinkProtocol: onenterdata,
-      autolinkEmail: onenterdata,
-      atxHeading: opener(heading),
-      blockQuote: opener(blockQuote),
-      characterEscape: onenterdata,
-      characterReference: onenterdata,
-      codeFenced: opener(codeFlow),
-      codeFencedFenceInfo: buffer,
-      codeFencedFenceMeta: buffer,
-      codeIndented: opener(codeFlow, buffer),
-      codeText: opener(codeText, buffer),
-      codeTextData: onenterdata,
-      data: onenterdata,
-      codeFlowValue: onenterdata,
-      definition: opener(definition),
-      definitionDestinationString: buffer,
-      definitionLabelString: buffer,
-      definitionTitleString: buffer,
-      emphasis: opener(emphasis),
-      hardBreakEscape: opener(hardBreak),
-      hardBreakTrailing: opener(hardBreak),
-      htmlFlow: opener(html, buffer),
-      htmlFlowData: onenterdata,
-      htmlText: opener(html, buffer),
-      htmlTextData: onenterdata,
-      image: opener(image),
-      label: buffer,
-      link: opener(link),
-      listItem: opener(listItem),
-      listItemValue: onenterlistitemvalue,
-      listOrdered: opener(list, onenterlistordered),
-      listUnordered: opener(list),
-      paragraph: opener(paragraph),
-      reference: onenterreference,
-      referenceString: buffer,
-      resourceDestinationString: buffer,
-      resourceTitleString: buffer,
-      setextHeading: opener(heading),
-      strong: opener(strong),
-      thematicBreak: opener(thematicBreak)
-    },
-    exit: {
-      atxHeading: closer(),
-      atxHeadingSequence: onexitatxheadingsequence,
-      autolink: closer(),
-      autolinkEmail: onexitautolinkemail,
-      autolinkProtocol: onexitautolinkprotocol,
-      blockQuote: closer(),
-      characterEscapeValue: onexitdata,
-      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
-      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
-      characterReferenceValue: onexitcharacterreferencevalue,
-      characterReference: onexitcharacterreference,
-      codeFenced: closer(onexitcodefenced),
-      codeFencedFence: onexitcodefencedfence,
-      codeFencedFenceInfo: onexitcodefencedfenceinfo,
-      codeFencedFenceMeta: onexitcodefencedfencemeta,
-      codeFlowValue: onexitdata,
-      codeIndented: closer(onexitcodeindented),
-      codeText: closer(onexitcodetext),
-      codeTextData: onexitdata,
-      data: onexitdata,
-      definition: closer(),
-      definitionDestinationString: onexitdefinitiondestinationstring,
-      definitionLabelString: onexitdefinitionlabelstring,
-      definitionTitleString: onexitdefinitiontitlestring,
-      emphasis: closer(),
-      hardBreakEscape: closer(onexithardbreak),
-      hardBreakTrailing: closer(onexithardbreak),
-      htmlFlow: closer(onexithtmlflow),
-      htmlFlowData: onexitdata,
-      htmlText: closer(onexithtmltext),
-      htmlTextData: onexitdata,
-      image: closer(onexitimage),
-      label: onexitlabel,
-      labelText: onexitlabeltext,
-      lineEnding: onexitlineending,
-      link: closer(onexitlink),
-      listItem: closer(),
-      listOrdered: closer(),
-      listUnordered: closer(),
-      paragraph: closer(),
-      referenceString: onexitreferencestring,
-      resourceDestinationString: onexitresourcedestinationstring,
-      resourceTitleString: onexitresourcetitlestring,
-      resource: onexitresource,
-      setextHeading: closer(onexitsetextheading),
-      setextHeadingLineSequence: onexitsetextheadinglinesequence,
-      setextHeadingText: onexitsetextheadingtext,
-      strong: closer(),
-      thematicBreak: closer()
-    }
-  };
-  configure(config, (options || {}).mdastExtensions || []);
-  const data = {};
-  return compile;
-  function compile(events) {
-    let tree = {
-      type: "root",
-      children: []
-    };
-    const context = {
-      stack: [tree],
-      tokenStack: [],
-      config,
-      enter,
-      exit,
-      buffer,
-      resume,
-      data
-    };
-    const listStack = [];
-    let index = -1;
-    while (++index < events.length) {
-      if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") {
-        if (events[index][0] === "enter") {
-          listStack.push(index);
-        } else {
-          const tail = listStack.pop();
-          index = prepareList(events, tail, index);
-        }
-      }
-    }
-    index = -1;
-    while (++index < events.length) {
-      const handler = config[events[index][0]];
-      if (own.call(handler, events[index][1].type)) {
-        handler[events[index][1].type].call(Object.assign({
-          sliceSerialize: events[index][2].sliceSerialize
-        }, context), events[index][1]);
-      }
-    }
-    if (context.tokenStack.length > 0) {
-      const tail = context.tokenStack[context.tokenStack.length - 1];
-      const handler = tail[1] || defaultOnError;
-      handler.call(context, void 0, tail[0]);
-    }
-    tree.position = {
-      start: point(events.length > 0 ? events[0][1].start : {
-        line: 1,
-        column: 1,
-        offset: 0
-      }),
-      end: point(events.length > 0 ? events[events.length - 2][1].end : {
-        line: 1,
-        column: 1,
-        offset: 0
-      })
-    };
-    index = -1;
-    while (++index < config.transforms.length) {
-      tree = config.transforms[index](tree) || tree;
-    }
-    return tree;
-  }
-  function prepareList(events, start, length) {
-    let index = start - 1;
-    let containerBalance = -1;
-    let listSpread = false;
-    let listItem2;
-    let lineIndex;
-    let firstBlankLineIndex;
-    let atMarker;
-    while (++index <= length) {
-      const event = events[index];
-      switch (event[1].type) {
-        case "listUnordered":
-        case "listOrdered":
-        case "blockQuote": {
-          if (event[0] === "enter") {
-            containerBalance++;
-          } else {
-            containerBalance--;
-          }
-          atMarker = void 0;
-          break;
-        }
-        case "lineEndingBlank": {
-          if (event[0] === "enter") {
-            if (listItem2 && !atMarker && !containerBalance && !firstBlankLineIndex) {
-              firstBlankLineIndex = index;
-            }
-            atMarker = void 0;
-          }
-          break;
-        }
-        case "linePrefix":
-        case "listItemValue":
-        case "listItemMarker":
-        case "listItemPrefix":
-        case "listItemPrefixWhitespace": {
-          break;
-        }
-        default: {
-          atMarker = void 0;
-        }
-      }
-      if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) {
-        if (listItem2) {
-          let tailIndex = index;
-          lineIndex = void 0;
-          while (tailIndex--) {
-            const tailEvent = events[tailIndex];
-            if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") {
-              if (tailEvent[0] === "exit") continue;
-              if (lineIndex) {
-                events[lineIndex][1].type = "lineEndingBlank";
-                listSpread = true;
-              }
-              tailEvent[1].type = "lineEnding";
-              lineIndex = tailIndex;
-            } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") ;
-            else {
-              break;
-            }
-          }
-          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {
-            listItem2._spread = true;
-          }
-          listItem2.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);
-          events.splice(lineIndex || index, 0, ["exit", listItem2, event[2]]);
-          index++;
-          length++;
-        }
-        if (event[1].type === "listItemPrefix") {
-          const item = {
-            type: "listItem",
-            _spread: false,
-            start: Object.assign({}, event[1].start),
-            // @ts-expect-error: we’ll add `end` in a second.
-            end: void 0
-          };
-          listItem2 = item;
-          events.splice(index, 0, ["enter", item, event[2]]);
-          index++;
-          length++;
-          firstBlankLineIndex = void 0;
-          atMarker = true;
-        }
-      }
-    }
-    events[start][1]._spread = listSpread;
-    return length;
-  }
-  function opener(create, and) {
-    return open;
-    function open(token) {
-      enter.call(this, create(token), token);
-      if (and) and.call(this, token);
-    }
-  }
-  function buffer() {
-    this.stack.push({
-      type: "fragment",
-      children: []
-    });
-  }
-  function enter(node, token, errorHandler) {
-    const parent = this.stack[this.stack.length - 1];
-    const siblings = parent.children;
-    siblings.push(node);
-    this.stack.push(node);
-    this.tokenStack.push([token, errorHandler || void 0]);
-    node.position = {
-      start: point(token.start),
-      // @ts-expect-error: `end` will be patched later.
-      end: void 0
-    };
-  }
-  function closer(and) {
-    return close;
-    function close(token) {
-      if (and) and.call(this, token);
-      exit.call(this, token);
-    }
-  }
-  function exit(token, onExitError) {
-    const node = this.stack.pop();
-    const open = this.tokenStack.pop();
-    if (!open) {
-      throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition({
-        start: token.start,
-        end: token.end
-      }) + "): it’s not open");
-    } else if (open[0].type !== token.type) {
-      if (onExitError) {
-        onExitError.call(this, token, open[0]);
-      } else {
-        const handler = open[1] || defaultOnError;
-        handler.call(this, token, open[0]);
-      }
-    }
-    node.position.end = point(token.end);
-  }
-  function resume() {
-    return toString(this.stack.pop());
-  }
-  function onenterlistordered() {
-    this.data.expectingFirstListItemValue = true;
-  }
-  function onenterlistitemvalue(token) {
-    if (this.data.expectingFirstListItemValue) {
-      const ancestor = this.stack[this.stack.length - 2];
-      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);
-      this.data.expectingFirstListItemValue = void 0;
-    }
-  }
-  function onexitcodefencedfenceinfo() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.lang = data2;
-  }
-  function onexitcodefencedfencemeta() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.meta = data2;
-  }
-  function onexitcodefencedfence() {
-    if (this.data.flowCodeInside) return;
-    this.buffer();
-    this.data.flowCodeInside = true;
-  }
-  function onexitcodefenced() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.value = data2.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
-    this.data.flowCodeInside = void 0;
-  }
-  function onexitcodeindented() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.value = data2.replace(/(\r?\n|\r)$/g, "");
-  }
-  function onexitdefinitionlabelstring(token) {
-    const label = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.label = label;
-    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
-  }
-  function onexitdefinitiontitlestring() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.title = data2;
-  }
-  function onexitdefinitiondestinationstring() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.url = data2;
-  }
-  function onexitatxheadingsequence(token) {
-    const node = this.stack[this.stack.length - 1];
-    if (!node.depth) {
-      const depth = this.sliceSerialize(token).length;
-      node.depth = depth;
-    }
-  }
-  function onexitsetextheadingtext() {
-    this.data.setextHeadingSlurpLineEnding = true;
-  }
-  function onexitsetextheadinglinesequence(token) {
-    const node = this.stack[this.stack.length - 1];
-    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;
-  }
-  function onexitsetextheading() {
-    this.data.setextHeadingSlurpLineEnding = void 0;
-  }
-  function onenterdata(token) {
-    const node = this.stack[this.stack.length - 1];
-    const siblings = node.children;
-    let tail = siblings[siblings.length - 1];
-    if (!tail || tail.type !== "text") {
-      tail = text();
-      tail.position = {
-        start: point(token.start),
-        // @ts-expect-error: we’ll add `end` later.
-        end: void 0
-      };
-      siblings.push(tail);
-    }
-    this.stack.push(tail);
-  }
-  function onexitdata(token) {
-    const tail = this.stack.pop();
-    tail.value += this.sliceSerialize(token);
-    tail.position.end = point(token.end);
-  }
-  function onexitlineending(token) {
-    const context = this.stack[this.stack.length - 1];
-    if (this.data.atHardBreak) {
-      const tail = context.children[context.children.length - 1];
-      tail.position.end = point(token.end);
-      this.data.atHardBreak = void 0;
-      return;
-    }
-    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {
-      onenterdata.call(this, token);
-      onexitdata.call(this, token);
-    }
-  }
-  function onexithardbreak() {
-    this.data.atHardBreak = true;
-  }
-  function onexithtmlflow() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.value = data2;
-  }
-  function onexithtmltext() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.value = data2;
-  }
-  function onexitcodetext() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.value = data2;
-  }
-  function onexitlink() {
-    const node = this.stack[this.stack.length - 1];
-    if (this.data.inReference) {
-      const referenceType = this.data.referenceType || "shortcut";
-      node.type += "Reference";
-      node.referenceType = referenceType;
-      delete node.url;
-      delete node.title;
-    } else {
-      delete node.identifier;
-      delete node.label;
-    }
-    this.data.referenceType = void 0;
-  }
-  function onexitimage() {
-    const node = this.stack[this.stack.length - 1];
-    if (this.data.inReference) {
-      const referenceType = this.data.referenceType || "shortcut";
-      node.type += "Reference";
-      node.referenceType = referenceType;
-      delete node.url;
-      delete node.title;
-    } else {
-      delete node.identifier;
-      delete node.label;
-    }
-    this.data.referenceType = void 0;
-  }
-  function onexitlabeltext(token) {
-    const string = this.sliceSerialize(token);
-    const ancestor = this.stack[this.stack.length - 2];
-    ancestor.label = decodeString(string);
-    ancestor.identifier = normalizeIdentifier(string).toLowerCase();
-  }
-  function onexitlabel() {
-    const fragment = this.stack[this.stack.length - 1];
-    const value = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    this.data.inReference = true;
-    if (node.type === "link") {
-      const children = fragment.children;
-      node.children = children;
-    } else {
-      node.alt = value;
-    }
-  }
-  function onexitresourcedestinationstring() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.url = data2;
-  }
-  function onexitresourcetitlestring() {
-    const data2 = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.title = data2;
-  }
-  function onexitresource() {
-    this.data.inReference = void 0;
-  }
-  function onenterreference() {
-    this.data.referenceType = "collapsed";
-  }
-  function onexitreferencestring(token) {
-    const label = this.resume();
-    const node = this.stack[this.stack.length - 1];
-    node.label = label;
-    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();
-    this.data.referenceType = "full";
-  }
-  function onexitcharacterreferencemarker(token) {
-    this.data.characterReferenceType = token.type;
-  }
-  function onexitcharacterreferencevalue(token) {
-    const data2 = this.sliceSerialize(token);
-    const type = this.data.characterReferenceType;
-    let value;
-    if (type) {
-      value = decodeNumericCharacterReference(data2, type === "characterReferenceMarkerNumeric" ? 10 : 16);
-      this.data.characterReferenceType = void 0;
-    } else {
-      const result = decodeNamedCharacterReference(data2);
-      value = result;
-    }
-    const tail = this.stack[this.stack.length - 1];
-    tail.value += value;
-  }
-  function onexitcharacterreference(token) {
-    const tail = this.stack.pop();
-    tail.position.end = point(token.end);
-  }
-  function onexitautolinkprotocol(token) {
-    onexitdata.call(this, token);
-    const node = this.stack[this.stack.length - 1];
-    node.url = this.sliceSerialize(token);
-  }
-  function onexitautolinkemail(token) {
-    onexitdata.call(this, token);
-    const node = this.stack[this.stack.length - 1];
-    node.url = "mailto:" + this.sliceSerialize(token);
-  }
-  function blockQuote() {
-    return {
-      type: "blockquote",
-      children: []
-    };
-  }
-  function codeFlow() {
-    return {
-      type: "code",
-      lang: null,
-      meta: null,
-      value: ""
-    };
-  }
-  function codeText() {
-    return {
-      type: "inlineCode",
-      value: ""
-    };
-  }
-  function definition() {
-    return {
-      type: "definition",
-      identifier: "",
-      label: null,
-      title: null,
-      url: ""
-    };
-  }
-  function emphasis() {
-    return {
-      type: "emphasis",
-      children: []
-    };
-  }
-  function heading() {
-    return {
-      type: "heading",
-      // @ts-expect-error `depth` will be set later.
-      depth: 0,
-      children: []
-    };
-  }
-  function hardBreak() {
-    return {
-      type: "break"
-    };
-  }
-  function html() {
-    return {
-      type: "html",
-      value: ""
-    };
-  }
-  function image() {
-    return {
-      type: "image",
-      title: null,
-      url: "",
-      alt: null
-    };
-  }
-  function link() {
-    return {
-      type: "link",
-      title: null,
-      url: "",
-      children: []
-    };
-  }
-  function list(token) {
-    return {
-      type: "list",
-      ordered: token.type === "listOrdered",
-      start: null,
-      spread: token._spread,
-      children: []
-    };
-  }
-  function listItem(token) {
-    return {
-      type: "listItem",
-      spread: token._spread,
-      checked: null,
-      children: []
-    };
-  }
-  function paragraph() {
-    return {
-      type: "paragraph",
-      children: []
-    };
-  }
-  function strong() {
-    return {
-      type: "strong",
-      children: []
-    };
-  }
-  function text() {
-    return {
-      type: "text",
-      value: ""
-    };
-  }
-  function thematicBreak() {
-    return {
-      type: "thematicBreak"
-    };
-  }
-}
-function point(d) {
-  return {
-    line: d.line,
-    column: d.column,
-    offset: d.offset
-  };
-}
-function configure(combined, extensions) {
-  let index = -1;
-  while (++index < extensions.length) {
-    const value = extensions[index];
-    if (Array.isArray(value)) {
-      configure(combined, value);
-    } else {
-      extension(combined, value);
-    }
-  }
-}
-function extension(combined, extension2) {
-  let key;
-  for (key in extension2) {
-    if (own.call(extension2, key)) {
-      switch (key) {
-        case "canContainEols": {
-          const right = extension2[key];
-          if (right) {
-            combined[key].push(...right);
-          }
-          break;
-        }
-        case "transforms": {
-          const right = extension2[key];
-          if (right) {
-            combined[key].push(...right);
-          }
-          break;
-        }
-        case "enter":
-        case "exit": {
-          const right = extension2[key];
-          if (right) {
-            Object.assign(combined[key], right);
-          }
-          break;
-        }
-      }
-    }
-  }
-}
-function defaultOnError(left, right) {
-  if (left) {
-    throw new Error("Cannot close `" + left.type + "` (" + stringifyPosition({
-      start: left.start,
-      end: left.end
-    }) + "): a different token (`" + right.type + "`, " + stringifyPosition({
-      start: right.start,
-      end: right.end
-    }) + ") is open");
-  } else {
-    throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({
-      start: right.start,
-      end: right.end
-    }) + ") is still open");
-  }
-}
-export {
-  fromMarkdown as f
-};