@gobolt/genesis 0.2.20 → 0.3.0

package/dist/node_modules/mdast-util-to-hast/lib/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+var footer = require("./footer.cjs");
+var state = require("./state.cjs");
+function toHast(tree, options) {
+  const state$1 = state.createState(tree, options);
+  const node = state$1.one(tree, void 0);
+  const foot = footer.footer(state$1);
+  const result = Array.isArray(node) ? { type: "root", children: node } : node || { type: "root", children: [] };
+  if (foot) {
+    result.children.push({ type: "text", value: "\n" }, foot);
+  }
+  return result;
+}
+exports.toHast = toHast;

package/dist/node_modules/mdast-util-to-hast/lib/index.js

@@ -0,0 +1,15 @@
+import { footer } from "./footer.js";
+import { createState } from "./state.js";
+function toHast(tree, options) {
+  const state = createState(tree, options);
+  const node = state.one(tree, void 0);
+  const foot = footer(state);
+  const result = Array.isArray(node) ? { type: "root", children: node } : node || { type: "root", children: [] };
+  if (foot) {
+    result.children.push({ type: "text", value: "\n" }, foot);
+  }
+  return result;
+}
+export {
+  toHast
+};

package/dist/node_modules/mdast-util-to-hast/lib/revert.cjs

@@ -0,0 +1,28 @@
+"use strict";
+function revert(state, node) {
+  const subtype = node.referenceType;
+  let suffix = "]";
+  if (subtype === "collapsed") {
+    suffix += "[]";
+  } else if (subtype === "full") {
+    suffix += "[" + (node.label || node.identifier) + "]";
+  }
+  if (node.type === "imageReference") {
+    return [{ type: "text", value: "![" + node.alt + suffix }];
+  }
+  const contents = state.all(node);
+  const head = contents[0];
+  if (head && head.type === "text") {
+    head.value = "[" + head.value;
+  } else {
+    contents.unshift({ type: "text", value: "[" });
+  }
+  const tail = contents[contents.length - 1];
+  if (tail && tail.type === "text") {
+    tail.value += suffix;
+  } else {
+    contents.push({ type: "text", value: suffix });
+  }
+  return contents;
+}
+exports.revert = revert;

package/dist/node_modules/mdast-util-to-hast/lib/revert.js

@@ -0,0 +1,29 @@
+function revert(state, node) {
+  const subtype = node.referenceType;
+  let suffix = "]";
+  if (subtype === "collapsed") {
+    suffix += "[]";
+  } else if (subtype === "full") {
+    suffix += "[" + (node.label || node.identifier) + "]";
+  }
+  if (node.type === "imageReference") {
+    return [{ type: "text", value: "![" + node.alt + suffix }];
+  }
+  const contents = state.all(node);
+  const head = contents[0];
+  if (head && head.type === "text") {
+    head.value = "[" + head.value;
+  } else {
+    contents.unshift({ type: "text", value: "[" });
+  }
+  const tail = contents[contents.length - 1];
+  if (tail && tail.type === "text") {
+    tail.value += suffix;
+  } else {
+    contents.push({ type: "text", value: suffix });
+  }
+  return contents;
+}
+export {
+  revert
+};

package/dist/node_modules/mdast-util-to-hast/lib/state.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var index$2 = require("../../@ungap/structured-clone/esm/index.cjs");
+var index$1 = require("./handlers/index.cjs");
+var index = require("../../unist-util-visit/lib/index.cjs");
+var index$3 = require("../../unist-util-position/lib/index.cjs");
+const own = {}.hasOwnProperty;
+const emptyOptions = {};
+function createState(tree, options) {
+  const settings = options || emptyOptions;
+  const definitionById = /* @__PURE__ */ new Map();
+  const footnoteById = /* @__PURE__ */ new Map();
+  const footnoteCounts = /* @__PURE__ */ new Map();
+  const handlers = { ...index$1.handlers, ...settings.handlers };
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
+    footnoteOrder: [],
+    handlers,
+    one,
+    options: settings,
+    patch,
+    wrap
+  };
+  index.visit(tree, function(node) {
+    if (node.type === "definition" || node.type === "footnoteDefinition") {
+      const map = node.type === "definition" ? definitionById : footnoteById;
+      const id = String(node.identifier).toUpperCase();
+      if (!map.has(id)) {
+        map.set(id, node);
+      }
+    }
+  });
+  return state;
+  function one(node, parent) {
+    const type = node.type;
+    const handle = state.handlers[type];
+    if (own.call(state.handlers, type) && handle) {
+      return handle(state, node, parent);
+    }
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ("children" in node) {
+        const { children, ...shallow } = node;
+        const result = index$2.default(shallow);
+        result.children = state.all(node);
+        return result;
+      }
+      return index$2.default(node);
+    }
+    const unknown = state.options.unknownHandler || defaultUnknownHandler;
+    return unknown(state, node, parent);
+  }
+  function all(parent) {
+    const values = [];
+    if ("children" in parent) {
+      const nodes = parent.children;
+      let index2 = -1;
+      while (++index2 < nodes.length) {
+        const result = state.one(nodes[index2], parent);
+        if (result) {
+          if (index2 && nodes[index2 - 1].type === "break") {
+            if (!Array.isArray(result) && result.type === "text") {
+              result.value = trimMarkdownSpaceStart(result.value);
+            }
+            if (!Array.isArray(result) && result.type === "element") {
+              const head = result.children[0];
+              if (head && head.type === "text") {
+                head.value = trimMarkdownSpaceStart(head.value);
+              }
+            }
+          }
+          if (Array.isArray(result)) {
+            values.push(...result);
+          } else {
+            values.push(result);
+          }
+        }
+      }
+    }
+    return values;
+  }
+}
+function patch(from, to) {
+  if (from.position) to.position = index$3.position(from);
+}
+function applyData(from, to) {
+  let result = to;
+  if (from && from.data) {
+    const hName = from.data.hName;
+    const hChildren = from.data.hChildren;
+    const hProperties = from.data.hProperties;
+    if (typeof hName === "string") {
+      if (result.type === "element") {
+        result.tagName = hName;
+      } else {
+        const children = "children" in result ? result.children : [result];
+        result = { type: "element", tagName: hName, properties: {}, children };
+      }
+    }
+    if (result.type === "element" && hProperties) {
+      Object.assign(result.properties, index$2.default(hProperties));
+    }
+    if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) {
+      result.children = hChildren;
+    }
+  }
+  return result;
+}
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {};
+  const result = "value" in node && !(own.call(data, "hProperties") || own.call(data, "hChildren")) ? { type: "text", value: node.value } : {
+    type: "element",
+    tagName: "div",
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+function wrap(nodes, loose) {
+  const result = [];
+  let index2 = -1;
+  if (loose) {
+    result.push({ type: "text", value: "\n" });
+  }
+  while (++index2 < nodes.length) {
+    if (index2) result.push({ type: "text", value: "\n" });
+    result.push(nodes[index2]);
+  }
+  if (loose && nodes.length > 0) {
+    result.push({ type: "text", value: "\n" });
+  }
+  return result;
+}
+function trimMarkdownSpaceStart(value) {
+  let index2 = 0;
+  let code = value.charCodeAt(index2);
+  while (code === 9 || code === 32) {
+    index2++;
+    code = value.charCodeAt(index2);
+  }
+  return value.slice(index2);
+}
+exports.createState = createState;
+exports.wrap = wrap;

package/dist/node_modules/mdast-util-to-hast/lib/state.js

@@ -0,0 +1,148 @@
+import structuredClone from "../../@ungap/structured-clone/esm/index.js";
+import { handlers } from "./handlers/index.js";
+import { visit } from "../../unist-util-visit/lib/index.js";
+import { position } from "../../unist-util-position/lib/index.js";
+const own = {}.hasOwnProperty;
+const emptyOptions = {};
+function createState(tree, options) {
+  const settings = options || emptyOptions;
+  const definitionById = /* @__PURE__ */ new Map();
+  const footnoteById = /* @__PURE__ */ new Map();
+  const footnoteCounts = /* @__PURE__ */ new Map();
+  const handlers$1 = { ...handlers, ...settings.handlers };
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
+    footnoteOrder: [],
+    handlers: handlers$1,
+    one,
+    options: settings,
+    patch,
+    wrap
+  };
+  visit(tree, function(node) {
+    if (node.type === "definition" || node.type === "footnoteDefinition") {
+      const map = node.type === "definition" ? definitionById : footnoteById;
+      const id = String(node.identifier).toUpperCase();
+      if (!map.has(id)) {
+        map.set(id, node);
+      }
+    }
+  });
+  return state;
+  function one(node, parent) {
+    const type = node.type;
+    const handle = state.handlers[type];
+    if (own.call(state.handlers, type) && handle) {
+      return handle(state, node, parent);
+    }
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ("children" in node) {
+        const { children, ...shallow } = node;
+        const result = structuredClone(shallow);
+        result.children = state.all(node);
+        return result;
+      }
+      return structuredClone(node);
+    }
+    const unknown = state.options.unknownHandler || defaultUnknownHandler;
+    return unknown(state, node, parent);
+  }
+  function all(parent) {
+    const values = [];
+    if ("children" in parent) {
+      const nodes = parent.children;
+      let index = -1;
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent);
+        if (result) {
+          if (index && nodes[index - 1].type === "break") {
+            if (!Array.isArray(result) && result.type === "text") {
+              result.value = trimMarkdownSpaceStart(result.value);
+            }
+            if (!Array.isArray(result) && result.type === "element") {
+              const head = result.children[0];
+              if (head && head.type === "text") {
+                head.value = trimMarkdownSpaceStart(head.value);
+              }
+            }
+          }
+          if (Array.isArray(result)) {
+            values.push(...result);
+          } else {
+            values.push(result);
+          }
+        }
+      }
+    }
+    return values;
+  }
+}
+function patch(from, to) {
+  if (from.position) to.position = position(from);
+}
+function applyData(from, to) {
+  let result = to;
+  if (from && from.data) {
+    const hName = from.data.hName;
+    const hChildren = from.data.hChildren;
+    const hProperties = from.data.hProperties;
+    if (typeof hName === "string") {
+      if (result.type === "element") {
+        result.tagName = hName;
+      } else {
+        const children = "children" in result ? result.children : [result];
+        result = { type: "element", tagName: hName, properties: {}, children };
+      }
+    }
+    if (result.type === "element" && hProperties) {
+      Object.assign(result.properties, structuredClone(hProperties));
+    }
+    if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) {
+      result.children = hChildren;
+    }
+  }
+  return result;
+}
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {};
+  const result = "value" in node && !(own.call(data, "hProperties") || own.call(data, "hChildren")) ? { type: "text", value: node.value } : {
+    type: "element",
+    tagName: "div",
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+function wrap(nodes, loose) {
+  const result = [];
+  let index = -1;
+  if (loose) {
+    result.push({ type: "text", value: "\n" });
+  }
+  while (++index < nodes.length) {
+    if (index) result.push({ type: "text", value: "\n" });
+    result.push(nodes[index]);
+  }
+  if (loose && nodes.length > 0) {
+    result.push({ type: "text", value: "\n" });
+  }
+  return result;
+}
+function trimMarkdownSpaceStart(value) {
+  let index = 0;
+  let code = value.charCodeAt(index);
+  while (code === 9 || code === 32) {
+    index++;
+    code = value.charCodeAt(index);
+  }
+  return value.slice(index);
+}
+export {
+  createState,
+  wrap
+};

package/dist/node_modules/mdast-util-to-string/lib/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+const emptyOptions = {};
+function toString(value, options) {
+  const settings = emptyOptions;
+  const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
+  const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
+  return one(value, includeImageAlt, includeHtml);
+}
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ("value" in value) {
+      return value.type === "html" && !includeHtml ? "" : value.value;
+    }
+    if (includeImageAlt && "alt" in value && value.alt) {
+      return value.alt;
+    }
+    if ("children" in value) {
+      return all(value.children, includeImageAlt, includeHtml);
+    }
+  }
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml);
+  }
+  return "";
+}
+function all(values, includeImageAlt, includeHtml) {
+  const result = [];
+  let index = -1;
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+  return result.join("");
+}
+function node(value) {
+  return Boolean(value && typeof value === "object");
+}
+exports.toString = toString;

package/dist/node_modules/mdast-util-to-string/lib/index.js

@@ -0,0 +1,38 @@
+const emptyOptions = {};
+function toString(value, options) {
+  const settings = emptyOptions;
+  const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
+  const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
+  return one(value, includeImageAlt, includeHtml);
+}
+function one(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
+    if ("value" in value) {
+      return value.type === "html" && !includeHtml ? "" : value.value;
+    }
+    if (includeImageAlt && "alt" in value && value.alt) {
+      return value.alt;
+    }
+    if ("children" in value) {
+      return all(value.children, includeImageAlt, includeHtml);
+    }
+  }
+  if (Array.isArray(value)) {
+    return all(value, includeImageAlt, includeHtml);
+  }
+  return "";
+}
+function all(values, includeImageAlt, includeHtml) {
+  const result = [];
+  let index = -1;
+  while (++index < values.length) {
+    result[index] = one(values[index], includeImageAlt, includeHtml);
+  }
+  return result.join("");
+}
+function node(value) {
+  return Boolean(value && typeof value === "object");
+}
+export {
+  toString
+};

package/dist/node_modules/micromark/lib/constructs.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var text$1 = require("./initialize/text.cjs");
+var blockQuote = require("../../micromark-core-commonmark/lib/block-quote.cjs");
+var list = require("../../micromark-core-commonmark/lib/list.cjs");
+var definition = require("../../micromark-core-commonmark/lib/definition.cjs");
+var codeIndented = require("../../micromark-core-commonmark/lib/code-indented.cjs");
+var codeFenced = require("../../micromark-core-commonmark/lib/code-fenced.cjs");
+var thematicBreak = require("../../micromark-core-commonmark/lib/thematic-break.cjs");
+var setextUnderline = require("../../micromark-core-commonmark/lib/setext-underline.cjs");
+var htmlFlow = require("../../micromark-core-commonmark/lib/html-flow.cjs");
+var headingAtx = require("../../micromark-core-commonmark/lib/heading-atx.cjs");
+var characterEscape = require("../../micromark-core-commonmark/lib/character-escape.cjs");
+var characterReference = require("../../micromark-core-commonmark/lib/character-reference.cjs");
+var codeText = require("../../micromark-core-commonmark/lib/code-text.cjs");
+var attention = require("../../micromark-core-commonmark/lib/attention.cjs");
+var labelEnd = require("../../micromark-core-commonmark/lib/label-end.cjs");
+var hardBreakEscape = require("../../micromark-core-commonmark/lib/hard-break-escape.cjs");
+var labelStartLink = require("../../micromark-core-commonmark/lib/label-start-link.cjs");
+var autolink = require("../../micromark-core-commonmark/lib/autolink.cjs");
+var htmlText = require("../../micromark-core-commonmark/lib/html-text.cjs");
+var labelStartImage = require("../../micromark-core-commonmark/lib/label-start-image.cjs");
+var lineEnding = require("../../micromark-core-commonmark/lib/line-ending.cjs");
+const document = {
+  [42]: list.list,
+  [43]: list.list,
+  [45]: list.list,
+  [48]: list.list,
+  [49]: list.list,
+  [50]: list.list,
+  [51]: list.list,
+  [52]: list.list,
+  [53]: list.list,
+  [54]: list.list,
+  [55]: list.list,
+  [56]: list.list,
+  [57]: list.list,
+  [62]: blockQuote.blockQuote
+};
+const contentInitial = {
+  [91]: definition.definition
+};
+const flowInitial = {
+  [-2]: codeIndented.codeIndented,
+  [-1]: codeIndented.codeIndented,
+  [32]: codeIndented.codeIndented
+};
+const flow = {
+  [35]: headingAtx.headingAtx,
+  [42]: thematicBreak.thematicBreak,
+  [45]: [setextUnderline.setextUnderline, thematicBreak.thematicBreak],
+  [60]: htmlFlow.htmlFlow,
+  [61]: setextUnderline.setextUnderline,
+  [95]: thematicBreak.thematicBreak,
+  [96]: codeFenced.codeFenced,
+  [126]: codeFenced.codeFenced
+};
+const string = {
+  [38]: characterReference.characterReference,
+  [92]: characterEscape.characterEscape
+};
+const text = {
+  [-5]: lineEnding.lineEnding,
+  [-4]: lineEnding.lineEnding,
+  [-3]: lineEnding.lineEnding,
+  [33]: labelStartImage.labelStartImage,
+  [38]: characterReference.characterReference,
+  [42]: attention.attention,
+  [60]: [autolink.autolink, htmlText.htmlText],
+  [91]: labelStartLink.labelStartLink,
+  [92]: [hardBreakEscape.hardBreakEscape, characterEscape.characterEscape],
+  [93]: labelEnd.labelEnd,
+  [95]: attention.attention,
+  [96]: codeText.codeText
+};
+const insideSpan = {
+  null: [attention.attention, text$1.resolver]
+};
+const attentionMarkers = {
+  null: [42, 95]
+};
+const disable = {
+  null: []
+};
+exports.attentionMarkers = attentionMarkers;
+exports.contentInitial = contentInitial;
+exports.disable = disable;
+exports.document = document;
+exports.flow = flow;
+exports.flowInitial = flowInitial;
+exports.insideSpan = insideSpan;
+exports.string = string;
+exports.text = text;

package/dist/node_modules/micromark/lib/constructs.js

@@ -0,0 +1,93 @@
+import { resolver } from "./initialize/text.js";
+import { blockQuote } from "../../micromark-core-commonmark/lib/block-quote.js";
+import { list } from "../../micromark-core-commonmark/lib/list.js";
+import { definition } from "../../micromark-core-commonmark/lib/definition.js";
+import { codeIndented } from "../../micromark-core-commonmark/lib/code-indented.js";
+import { codeFenced } from "../../micromark-core-commonmark/lib/code-fenced.js";
+import { thematicBreak } from "../../micromark-core-commonmark/lib/thematic-break.js";
+import { setextUnderline } from "../../micromark-core-commonmark/lib/setext-underline.js";
+import { htmlFlow } from "../../micromark-core-commonmark/lib/html-flow.js";
+import { headingAtx } from "../../micromark-core-commonmark/lib/heading-atx.js";
+import { characterEscape } from "../../micromark-core-commonmark/lib/character-escape.js";
+import { characterReference } from "../../micromark-core-commonmark/lib/character-reference.js";
+import { codeText } from "../../micromark-core-commonmark/lib/code-text.js";
+import { attention } from "../../micromark-core-commonmark/lib/attention.js";
+import { labelEnd } from "../../micromark-core-commonmark/lib/label-end.js";
+import { hardBreakEscape } from "../../micromark-core-commonmark/lib/hard-break-escape.js";
+import { labelStartLink } from "../../micromark-core-commonmark/lib/label-start-link.js";
+import { autolink } from "../../micromark-core-commonmark/lib/autolink.js";
+import { htmlText } from "../../micromark-core-commonmark/lib/html-text.js";
+import { labelStartImage } from "../../micromark-core-commonmark/lib/label-start-image.js";
+import { lineEnding } from "../../micromark-core-commonmark/lib/line-ending.js";
+const document = {
+  [42]: list,
+  [43]: list,
+  [45]: list,
+  [48]: list,
+  [49]: list,
+  [50]: list,
+  [51]: list,
+  [52]: list,
+  [53]: list,
+  [54]: list,
+  [55]: list,
+  [56]: list,
+  [57]: list,
+  [62]: blockQuote
+};
+const contentInitial = {
+  [91]: definition
+};
+const flowInitial = {
+  [-2]: codeIndented,
+  [-1]: codeIndented,
+  [32]: codeIndented
+};
+const flow = {
+  [35]: headingAtx,
+  [42]: thematicBreak,
+  [45]: [setextUnderline, thematicBreak],
+  [60]: htmlFlow,
+  [61]: setextUnderline,
+  [95]: thematicBreak,
+  [96]: codeFenced,
+  [126]: codeFenced
+};
+const string = {
+  [38]: characterReference,
+  [92]: characterEscape
+};
+const text = {
+  [-5]: lineEnding,
+  [-4]: lineEnding,
+  [-3]: lineEnding,
+  [33]: labelStartImage,
+  [38]: characterReference,
+  [42]: attention,
+  [60]: [autolink, htmlText],
+  [91]: labelStartLink,
+  [92]: [hardBreakEscape, characterEscape],
+  [93]: labelEnd,
+  [95]: attention,
+  [96]: codeText
+};
+const insideSpan = {
+  null: [attention, resolver]
+};
+const attentionMarkers = {
+  null: [42, 95]
+};
+const disable = {
+  null: []
+};
+export {
+  attentionMarkers,
+  contentInitial,
+  disable,
+  document,
+  flow,
+  flowInitial,
+  insideSpan,
+  string,
+  text
+};