@gobolt/genesis 0.2.20 → 0.3.0

package/dist/node_modules/react-markdown/lib/index.js

@@ -0,0 +1,149 @@
+import { unreachable } from "../../devlop/lib/default.js";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import "react";
+import { unified } from "../../unified/lib/index.js";
+import remarkParse from "../../remark-parse/lib/index.js";
+import remarkRehype from "../../remark-rehype/lib/index.js";
+import { VFile } from "../../vfile/lib/index.js";
+import { visit } from "../../unist-util-visit/lib/index.js";
+import { toJsxRuntime } from "../../hast-util-to-jsx-runtime/lib/index.js";
+import { urlAttributes } from "../../html-url-attributes/lib/index.js";
+const changelog = "https://github.com/remarkjs/react-markdown/blob/main/changelog.md";
+const emptyPlugins = [];
+const emptyRemarkRehypeOptions = { allowDangerousHtml: true };
+const safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
+const deprecations = [
+  { from: "astPlugins", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "allowDangerousHtml", id: "remove-buggy-html-in-markdown-parser" },
+  {
+    from: "allowNode",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowElement"
+  },
+  {
+    from: "allowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "allowedElements"
+  },
+  { from: "className", id: "remove-classname" },
+  {
+    from: "disallowedTypes",
+    id: "replace-allownode-allowedtypes-and-disallowedtypes",
+    to: "disallowedElements"
+  },
+  { from: "escapeHtml", id: "remove-buggy-html-in-markdown-parser" },
+  { from: "includeElementIndex", id: "#remove-includeelementindex" },
+  {
+    from: "includeNodeIndex",
+    id: "change-includenodeindex-to-includeelementindex"
+  },
+  { from: "linkTarget", id: "remove-linktarget" },
+  { from: "plugins", id: "change-plugins-to-remarkplugins", to: "remarkPlugins" },
+  { from: "rawSourcePos", id: "#remove-rawsourcepos" },
+  { from: "renderers", id: "change-renderers-to-components", to: "components" },
+  { from: "source", id: "change-source-to-children", to: "children" },
+  { from: "sourcePos", id: "#remove-sourcepos" },
+  { from: "transformImageUri", id: "#add-urltransform", to: "urlTransform" },
+  { from: "transformLinkUri", id: "#add-urltransform", to: "urlTransform" }
+];
+function Markdown(options) {
+  const processor = createProcessor(options);
+  const file = createFile(options);
+  return post(processor.runSync(processor.parse(file), file), options);
+}
+function createProcessor(options) {
+  const rehypePlugins = options.rehypePlugins || emptyPlugins;
+  const remarkPlugins = options.remarkPlugins || emptyPlugins;
+  const remarkRehypeOptions = options.remarkRehypeOptions ? { ...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions } : emptyRemarkRehypeOptions;
+  const processor = unified().use(remarkParse).use(remarkPlugins).use(remarkRehype, remarkRehypeOptions).use(rehypePlugins);
+  return processor;
+}
+function createFile(options) {
+  const children = options.children || "";
+  const file = new VFile();
+  if (typeof children === "string") {
+    file.value = children;
+  }
+  return file;
+}
+function post(tree, options) {
+  const allowedElements = options.allowedElements;
+  const allowElement = options.allowElement;
+  const components = options.components;
+  const disallowedElements = options.disallowedElements;
+  const skipHtml = options.skipHtml;
+  const unwrapDisallowed = options.unwrapDisallowed;
+  const urlTransform = options.urlTransform || defaultUrlTransform;
+  for (const deprecation of deprecations) {
+    if (Object.hasOwn(options, deprecation.from)) {
+      unreachable(
+        "Unexpected `" + deprecation.from + "` prop, " + (deprecation.to ? "use `" + deprecation.to + "` instead" : "remove it") + " (see <" + changelog + "#" + deprecation.id + "> for more info)"
+      );
+    }
+  }
+  visit(tree, transform);
+  return toJsxRuntime(tree, {
+    Fragment,
+    components,
+    ignoreInvalidStyle: true,
+    jsx,
+    jsxs,
+    passKeys: true,
+    passNode: true
+  });
+  function transform(node, index, parent) {
+    if (node.type === "raw" && parent && typeof index === "number") {
+      if (skipHtml) {
+        parent.children.splice(index, 1);
+      } else {
+        parent.children[index] = { type: "text", value: node.value };
+      }
+      return index;
+    }
+    if (node.type === "element") {
+      let key;
+      for (key in urlAttributes) {
+        if (Object.hasOwn(urlAttributes, key) && Object.hasOwn(node.properties, key)) {
+          const value = node.properties[key];
+          const test = urlAttributes[key];
+          if (test === null || test.includes(node.tagName)) {
+            node.properties[key] = urlTransform(String(value || ""), key, node);
+          }
+        }
+      }
+    }
+    if (node.type === "element") {
+      let remove = allowedElements ? !allowedElements.includes(node.tagName) : disallowedElements ? disallowedElements.includes(node.tagName) : false;
+      if (!remove && allowElement && typeof index === "number") {
+        remove = !allowElement(node, index, parent);
+      }
+      if (remove && parent && typeof index === "number") {
+        if (unwrapDisallowed && node.children) {
+          parent.children.splice(index, 1, ...node.children);
+        } else {
+          parent.children.splice(index, 1);
+        }
+        return index;
+      }
+    }
+  }
+}
+function defaultUrlTransform(value) {
+  const colon = value.indexOf(":");
+  const questionMark = value.indexOf("?");
+  const numberSign = value.indexOf("#");
+  const slash = value.indexOf("/");
+  if (
+    // If there is no protocol, it’s relative.
+    colon === -1 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.
+    slash !== -1 && colon > slash || questionMark !== -1 && colon > questionMark || numberSign !== -1 && colon > numberSign || // It is a protocol, it should be allowed.
+    safeProtocol.test(value.slice(0, colon))
+  ) {
+    return value;
+  }
+  return "";
+}
+export {
+  Markdown,
+  defaultUrlTransform
+};

package/dist/node_modules/remark-parse/lib/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var index = require("../../mdast-util-from-markdown/lib/index.cjs");
+function remarkParse(options) {
+  const self = this;
+  self.parser = parser;
+  function parser(doc) {
+    return index.fromMarkdown(doc, {
+      ...self.data("settings"),
+      ...options,
+      // Note: these options are not in the readme.
+      // The goal is for them to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data("micromarkExtensions") || [],
+      mdastExtensions: self.data("fromMarkdownExtensions") || []
+    });
+  }
+}
+module.exports = remarkParse;

package/dist/node_modules/remark-parse/lib/index.js

@@ -0,0 +1,19 @@
+import { fromMarkdown } from "../../mdast-util-from-markdown/lib/index.js";
+function remarkParse(options) {
+  const self = this;
+  self.parser = parser;
+  function parser(doc) {
+    return fromMarkdown(doc, {
+      ...self.data("settings"),
+      ...options,
+      // Note: these options are not in the readme.
+      // The goal is for them to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data("micromarkExtensions") || [],
+      mdastExtensions: self.data("fromMarkdownExtensions") || []
+    });
+  }
+}
+export {
+  remarkParse as default
+};

package/dist/node_modules/remark-rehype/lib/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var index = require("../../mdast-util-to-hast/lib/index.cjs");
+function remarkRehype(destination, options) {
+  if (destination && "run" in destination) {
+    return async function(tree, file) {
+      const hastTree = (
+        /** @type {HastRoot} */
+        index.toHast(tree, { file, ...options })
+      );
+      await destination.run(hastTree, file);
+    };
+  }
+  return function(tree, file) {
+    return (
+      /** @type {HastRoot} */
+      index.toHast(tree, { file, ...destination || options })
+    );
+  };
+}
+module.exports = remarkRehype;

package/dist/node_modules/remark-rehype/lib/index.js

@@ -0,0 +1,21 @@
+import { toHast } from "../../mdast-util-to-hast/lib/index.js";
+function remarkRehype(destination, options) {
+  if (destination && "run" in destination) {
+    return async function(tree, file) {
+      const hastTree = (
+        /** @type {HastRoot} */
+        toHast(tree, { file, ...options })
+      );
+      await destination.run(hastTree, file);
+    };
+  }
+  return function(tree, file) {
+    return (
+      /** @type {HastRoot} */
+      toHast(tree, { file, ...destination || options })
+    );
+  };
+}
+export {
+  remarkRehype as default
+};

package/dist/node_modules/socket.io-client/build/esm/contrib/backo2.cjs

@@ -0,0 +1,31 @@
+"use strict";
+function Backoff(opts) {
+  opts = opts || {};
+  this.ms = opts.min || 100;
+  this.max = opts.max || 1e4;
+  this.factor = opts.factor || 2;
+  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+  this.attempts = 0;
+}
+Backoff.prototype.duration = function() {
+  var ms = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var rand = Math.random();
+    var deviation = Math.floor(rand * this.jitter * ms);
+    ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+  }
+  return Math.min(ms, this.max) | 0;
+};
+Backoff.prototype.reset = function() {
+  this.attempts = 0;
+};
+Backoff.prototype.setMin = function(min) {
+  this.ms = min;
+};
+Backoff.prototype.setMax = function(max) {
+  this.max = max;
+};
+Backoff.prototype.setJitter = function(jitter) {
+  this.jitter = jitter;
+};
+exports.Backoff = Backoff;

package/dist/node_modules/socket.io-client/build/esm/contrib/backo2.js

@@ -0,0 +1,32 @@
+function Backoff(opts) {
+  opts = opts || {};
+  this.ms = opts.min || 100;
+  this.max = opts.max || 1e4;
+  this.factor = opts.factor || 2;
+  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+  this.attempts = 0;
+}
+Backoff.prototype.duration = function() {
+  var ms = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var rand = Math.random();
+    var deviation = Math.floor(rand * this.jitter * ms);
+    ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+  }
+  return Math.min(ms, this.max) | 0;
+};
+Backoff.prototype.reset = function() {
+  this.attempts = 0;
+};
+Backoff.prototype.setMin = function(min) {
+  this.ms = min;
+};
+Backoff.prototype.setMax = function(max) {
+  this.max = max;
+};
+Backoff.prototype.setJitter = function(jitter) {
+  this.jitter = jitter;
+};
+export {
+  Backoff
+};

package/dist/node_modules/socket.io-client/build/esm/index.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var url = require("./url.cjs");
+var manager = require("./manager.cjs");
+var socket = require("./socket.cjs");
+var index = require("../../../socket.io-parser/build/esm/index.cjs");
+require("../../../engine.io-client/build/esm/socket.cjs");
+require("../../../engine.io-parser/build/esm/encodePacket.browser.cjs");
+require("../../../engine.io-parser/build/esm/commons.cjs");
+require("../../../engine.io-parser/build/esm/contrib/base64-arraybuffer.cjs");
+require("../../../@socket.io/component-emitter/lib/esm/index.cjs");
+require("../../../engine.io-client/build/esm/util.cjs");
+var pollingXhr = require("../../../engine.io-client/build/esm/transports/polling-xhr.cjs");
+var websocket = require("../../../engine.io-client/build/esm/transports/websocket.cjs");
+require("../../../engine.io-client/build/esm/globals.cjs");
+const cache = {};
+function lookup(uri, opts) {
+  if (typeof uri === "object") {
+    opts = uri;
+    uri = void 0;
+  }
+  opts = opts || {};
+  const parsed = url.url(uri, opts.path || "/socket.io");
+  const source = parsed.source;
+  const id = parsed.id;
+  const path = parsed.path;
+  const sameNamespace = cache[id] && path in cache[id]["nsps"];
+  const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
+  let io;
+  if (newConnection) {
+    io = new manager.Manager(source, opts);
+  } else {
+    if (!cache[id]) {
+      cache[id] = new manager.Manager(source, opts);
+    }
+    io = cache[id];
+  }
+  if (parsed.query && !opts.query) {
+    opts.query = parsed.queryKey;
+  }
+  return io.socket(parsed.path, opts);
+}
+Object.assign(lookup, {
+  Manager: manager.Manager,
+  Socket: socket.Socket,
+  io: lookup,
+  connect: lookup
+});
+exports.Manager = manager.Manager;
+exports.Socket = socket.Socket;
+exports.protocol = index.protocol;
+exports.NodeXHR = pollingXhr.XHR;
+exports.XHR = pollingXhr.XHR;
+exports.NodeWebSocket = websocket.WS;
+exports.WebSocket = websocket.WS;
+exports.connect = lookup;
+exports.default = lookup;
+exports.io = lookup;

package/dist/node_modules/socket.io-client/build/esm/index.js

@@ -0,0 +1,58 @@
+import { url } from "./url.js";
+import { Manager } from "./manager.js";
+import { Socket } from "./socket.js";
+import { protocol } from "../../../socket.io-parser/build/esm/index.js";
+import "../../../engine.io-client/build/esm/socket.js";
+import "../../../engine.io-parser/build/esm/encodePacket.browser.js";
+import "../../../engine.io-parser/build/esm/commons.js";
+import "../../../engine.io-parser/build/esm/contrib/base64-arraybuffer.js";
+import "../../../@socket.io/component-emitter/lib/esm/index.js";
+import "../../../engine.io-client/build/esm/util.js";
+import { XHR, XHR as XHR2 } from "../../../engine.io-client/build/esm/transports/polling-xhr.js";
+import { WS, WS as WS2 } from "../../../engine.io-client/build/esm/transports/websocket.js";
+import "../../../engine.io-client/build/esm/globals.js";
+const cache = {};
+function lookup(uri, opts) {
+  if (typeof uri === "object") {
+    opts = uri;
+    uri = void 0;
+  }
+  opts = opts || {};
+  const parsed = url(uri, opts.path || "/socket.io");
+  const source = parsed.source;
+  const id = parsed.id;
+  const path = parsed.path;
+  const sameNamespace = cache[id] && path in cache[id]["nsps"];
+  const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
+  let io;
+  if (newConnection) {
+    io = new Manager(source, opts);
+  } else {
+    if (!cache[id]) {
+      cache[id] = new Manager(source, opts);
+    }
+    io = cache[id];
+  }
+  if (parsed.query && !opts.query) {
+    opts.query = parsed.queryKey;
+  }
+  return io.socket(parsed.path, opts);
+}
+Object.assign(lookup, {
+  Manager,
+  Socket,
+  io: lookup,
+  connect: lookup
+});
+export {
+  Manager,
+  WS as NodeWebSocket,
+  XHR as NodeXHR,
+  Socket,
+  WS2 as WebSocket,
+  XHR2 as XHR,
+  lookup as connect,
+  lookup as default,
+  lookup as io,
+  protocol
+};