@gobolt/genesis 0.2.20 → 0.3.0

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var types = require("./types.cjs");
+const env = typeof self === "object" ? self : globalThis;
+const deserializer = ($, _) => {
+  const as = (out, index) => {
+    $.set(index, out);
+    return out;
+  };
+  const unpair = (index) => {
+    if ($.has(index))
+      return $.get(index);
+    const [type, value] = _[index];
+    switch (type) {
+      case types.PRIMITIVE:
+      case types.VOID:
+        return as(value, index);
+      case types.ARRAY: {
+        const arr = as([], index);
+        for (const index2 of value)
+          arr.push(unpair(index2));
+        return arr;
+      }
+      case types.OBJECT: {
+        const object = as({}, index);
+        for (const [key, index2] of value)
+          object[unpair(key)] = unpair(index2);
+        return object;
+      }
+      case types.DATE:
+        return as(new Date(value), index);
+      case types.REGEXP: {
+        const { source, flags } = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case types.MAP: {
+        const map = as(/* @__PURE__ */ new Map(), index);
+        for (const [key, index2] of value)
+          map.set(unpair(key), unpair(index2));
+        return map;
+      }
+      case types.SET: {
+        const set = as(/* @__PURE__ */ new Set(), index);
+        for (const index2 of value)
+          set.add(unpair(index2));
+        return set;
+      }
+      case types.ERROR: {
+        const { name, message } = value;
+        return as(new env[name](message), index);
+      }
+      case types.BIGINT:
+        return as(BigInt(value), index);
+      case "BigInt":
+        return as(Object(BigInt(value)), index);
+      case "ArrayBuffer":
+        return as(new Uint8Array(value).buffer, value);
+      case "DataView": {
+        const { buffer } = new Uint8Array(value);
+        return as(new DataView(buffer), value);
+      }
+    }
+    return as(new env[type](value), index);
+  };
+  return unpair;
+};
+const deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+exports.deserialize = deserialize;

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.js

@@ -0,0 +1,68 @@
+import { BIGINT, ERROR, SET, MAP, REGEXP, DATE, OBJECT, ARRAY, VOID, PRIMITIVE } from "./types.js";
+const env = typeof self === "object" ? self : globalThis;
+const deserializer = ($, _) => {
+  const as = (out, index) => {
+    $.set(index, out);
+    return out;
+  };
+  const unpair = (index) => {
+    if ($.has(index))
+      return $.get(index);
+    const [type, value] = _[index];
+    switch (type) {
+      case PRIMITIVE:
+      case VOID:
+        return as(value, index);
+      case ARRAY: {
+        const arr = as([], index);
+        for (const index2 of value)
+          arr.push(unpair(index2));
+        return arr;
+      }
+      case OBJECT: {
+        const object = as({}, index);
+        for (const [key, index2] of value)
+          object[unpair(key)] = unpair(index2);
+        return object;
+      }
+      case DATE:
+        return as(new Date(value), index);
+      case REGEXP: {
+        const { source, flags } = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case MAP: {
+        const map = as(/* @__PURE__ */ new Map(), index);
+        for (const [key, index2] of value)
+          map.set(unpair(key), unpair(index2));
+        return map;
+      }
+      case SET: {
+        const set = as(/* @__PURE__ */ new Set(), index);
+        for (const index2 of value)
+          set.add(unpair(index2));
+        return set;
+      }
+      case ERROR: {
+        const { name, message } = value;
+        return as(new env[name](message), index);
+      }
+      case BIGINT:
+        return as(BigInt(value), index);
+      case "BigInt":
+        return as(Object(BigInt(value)), index);
+      case "ArrayBuffer":
+        return as(new Uint8Array(value).buffer, value);
+      case "DataView": {
+        const { buffer } = new Uint8Array(value);
+        return as(new DataView(buffer), value);
+      }
+    }
+    return as(new env[type](value), index);
+  };
+  return unpair;
+};
+const deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+export {
+  deserialize
+};

package/dist/node_modules/@ungap/structured-clone/esm/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var deserialize = require("./deserialize.cjs");
+var serialize = require("./serialize.cjs");
+var structuredClone$1 = typeof structuredClone === "function" ? (
+  /* c8 ignore start */
+  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize.deserialize(serialize.serialize(any, options)) : structuredClone(any)
+) : (any, options) => deserialize.deserialize(serialize.serialize(any, options));
+exports.deserialize = deserialize.deserialize;
+exports.serialize = serialize.serialize;
+exports.default = structuredClone$1;

package/dist/node_modules/@ungap/structured-clone/esm/index.js

@@ -0,0 +1,11 @@
+import { deserialize } from "./deserialize.js";
+import { serialize } from "./serialize.js";
+var structuredClone$1 = typeof structuredClone === "function" ? (
+  /* c8 ignore start */
+  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
+) : (any, options) => deserialize(serialize(any, options));
+export {
+  structuredClone$1 as default,
+  deserialize,
+  serialize
+};

package/dist/node_modules/@ungap/structured-clone/esm/serialize.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var types = require("./types.cjs");
+const EMPTY = "";
+const { toString } = {};
+const { keys } = Object;
+const typeOf = (value) => {
+  const type = typeof value;
+  if (type !== "object" || !value)
+    return [types.PRIMITIVE, type];
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case "Array":
+      return [types.ARRAY, EMPTY];
+    case "Object":
+      return [types.OBJECT, EMPTY];
+    case "Date":
+      return [types.DATE, EMPTY];
+    case "RegExp":
+      return [types.REGEXP, EMPTY];
+    case "Map":
+      return [types.MAP, EMPTY];
+    case "Set":
+      return [types.SET, EMPTY];
+    case "DataView":
+      return [types.ARRAY, asString];
+  }
+  if (asString.includes("Array"))
+    return [types.ARRAY, asString];
+  if (asString.includes("Error"))
+    return [types.ERROR, asString];
+  return [types.OBJECT, asString];
+};
+const shouldSkip = ([TYPE, type]) => TYPE === types.PRIMITIVE && (type === "function" || type === "symbol");
+const serializer = (strict, json, $, _) => {
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+  const pair = (value) => {
+    if ($.has(value))
+      return $.get(value);
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case types.PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case "bigint":
+            TYPE = types.BIGINT;
+            entry = value.toString();
+            break;
+          case "function":
+          case "symbol":
+            if (strict)
+              throw new TypeError("unable to serialize " + type);
+            entry = null;
+            break;
+          case "undefined":
+            return as([types.VOID], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case types.ARRAY: {
+        if (type) {
+          let spread = value;
+          if (type === "DataView") {
+            spread = new Uint8Array(value.buffer);
+          } else if (type === "ArrayBuffer") {
+            spread = new Uint8Array(value);
+          }
+          return as([type, [...spread]], value);
+        }
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case types.OBJECT: {
+        if (type) {
+          switch (type) {
+            case "BigInt":
+              return as([type, value.toString()], value);
+            case "Boolean":
+            case "Number":
+            case "String":
+              return as([type, value.valueOf()], value);
+          }
+        }
+        if (json && "toJSON" in value)
+          return pair(value.toJSON());
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case types.DATE:
+        return as([TYPE, value.toISOString()], value);
+      case types.REGEXP: {
+        const { source, flags } = value;
+        return as([TYPE, { source, flags }], value);
+      }
+      case types.MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case types.SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+    const { message } = value;
+    return as([TYPE, { name: type, message }], value);
+  };
+  return pair;
+};
+const serialize = (value, { json, lossy } = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
+};
+exports.serialize = serialize;

package/dist/node_modules/@ungap/structured-clone/esm/serialize.js

@@ -0,0 +1,135 @@
+import { SET, MAP, REGEXP, DATE, OBJECT, ARRAY, PRIMITIVE, BIGINT, ERROR, VOID } from "./types.js";
+const EMPTY = "";
+const { toString } = {};
+const { keys } = Object;
+const typeOf = (value) => {
+  const type = typeof value;
+  if (type !== "object" || !value)
+    return [PRIMITIVE, type];
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case "Array":
+      return [ARRAY, EMPTY];
+    case "Object":
+      return [OBJECT, EMPTY];
+    case "Date":
+      return [DATE, EMPTY];
+    case "RegExp":
+      return [REGEXP, EMPTY];
+    case "Map":
+      return [MAP, EMPTY];
+    case "Set":
+      return [SET, EMPTY];
+    case "DataView":
+      return [ARRAY, asString];
+  }
+  if (asString.includes("Array"))
+    return [ARRAY, asString];
+  if (asString.includes("Error"))
+    return [ERROR, asString];
+  return [OBJECT, asString];
+};
+const shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
+const serializer = (strict, json, $, _) => {
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+  const pair = (value) => {
+    if ($.has(value))
+      return $.get(value);
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case "bigint":
+            TYPE = BIGINT;
+            entry = value.toString();
+            break;
+          case "function":
+          case "symbol":
+            if (strict)
+              throw new TypeError("unable to serialize " + type);
+            entry = null;
+            break;
+          case "undefined":
+            return as([VOID], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case ARRAY: {
+        if (type) {
+          let spread = value;
+          if (type === "DataView") {
+            spread = new Uint8Array(value.buffer);
+          } else if (type === "ArrayBuffer") {
+            spread = new Uint8Array(value);
+          }
+          return as([type, [...spread]], value);
+        }
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case OBJECT: {
+        if (type) {
+          switch (type) {
+            case "BigInt":
+              return as([type, value.toString()], value);
+            case "Boolean":
+            case "Number":
+            case "String":
+              return as([type, value.valueOf()], value);
+          }
+        }
+        if (json && "toJSON" in value)
+          return pair(value.toJSON());
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case DATE:
+        return as([TYPE, value.toISOString()], value);
+      case REGEXP: {
+        const { source, flags } = value;
+        return as([TYPE, { source, flags }], value);
+      }
+      case MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+    const { message } = value;
+    return as([TYPE, { name: type, message }], value);
+  };
+  return pair;
+};
+const serialize = (value, { json, lossy } = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
+};
+export {
+  serialize
+};

package/dist/node_modules/@ungap/structured-clone/esm/types.cjs

@@ -0,0 +1,21 @@
+"use strict";
+const VOID = -1;
+const PRIMITIVE = 0;
+const ARRAY = 1;
+const OBJECT = 2;
+const DATE = 3;
+const REGEXP = 4;
+const MAP = 5;
+const SET = 6;
+const ERROR = 7;
+const BIGINT = 8;
+exports.ARRAY = ARRAY;
+exports.BIGINT = BIGINT;
+exports.DATE = DATE;
+exports.ERROR = ERROR;
+exports.MAP = MAP;
+exports.OBJECT = OBJECT;
+exports.PRIMITIVE = PRIMITIVE;
+exports.REGEXP = REGEXP;
+exports.SET = SET;
+exports.VOID = VOID;

package/dist/node_modules/@ungap/structured-clone/esm/types.js

@@ -0,0 +1,22 @@
+const VOID = -1;
+const PRIMITIVE = 0;
+const ARRAY = 1;
+const OBJECT = 2;
+const DATE = 3;
+const REGEXP = 4;
+const MAP = 5;
+const SET = 6;
+const ERROR = 7;
+const BIGINT = 8;
+export {
+  ARRAY,
+  BIGINT,
+  DATE,
+  ERROR,
+  MAP,
+  OBJECT,
+  PRIMITIVE,
+  REGEXP,
+  SET,
+  VOID
+};

package/dist/node_modules/antd/es/typography/hooks/useCopyClick.cjs

@@ -1,6 +1,6 @@
 "use strict";
 var React = require("react");
-var index = require("../../../../../_virtual/index6.cjs");
+var index = require("../../../../../_virtual/index5.cjs");
 var useEvent = require("../../../../rc-util/es/hooks/useEvent.cjs");
 var toList = require("../../_util/toList.cjs");
 function _interopNamespaceDefault(e) {

package/dist/node_modules/antd/es/typography/hooks/useCopyClick.js

@@ -1,5 +1,5 @@
 import * as React from "react";
-import copy from "../../../../../_virtual/index6.js";
+import copy from "../../../../../_virtual/index5.js";
 import useEvent from "../../../../rc-util/es/hooks/useEvent.js";
 import toList from "../../_util/toList.js";
 var __awaiter = function(thisArg, _arguments, P, generator) {

package/dist/node_modules/bail/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+function bail(error) {
+  if (error) {
+    throw error;
+  }
+}
+exports.bail = bail;

package/dist/node_modules/bail/index.js

@@ -0,0 +1,8 @@
+function bail(error) {
+  if (error) {
+    throw error;
+  }
+}
+export {
+  bail
+};

package/dist/node_modules/comma-separated-tokens/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+function stringify(values, options) {
+  const settings = {};
+  const input = values[values.length - 1] === "" ? [...values, ""] : values;
+  return input.join(
+    (settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
+  ).trim();
+}
+exports.stringify = stringify;

package/dist/node_modules/comma-separated-tokens/index.js

@@ -0,0 +1,10 @@
+function stringify(values, options) {
+  const settings = {};
+  const input = values[values.length - 1] === "" ? [...values, ""] : values;
+  return input.join(
+    (settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
+  ).trim();
+}
+export {
+  stringify
+};

package/dist/node_modules/decode-named-character-reference/index.dom.cjs

@@ -0,0 +1,16 @@
+"use strict";
+const element = document.createElement("i");
+function decodeNamedCharacterReference(value) {
+  const characterReference = "&" + value + ";";
+  element.innerHTML = characterReference;
+  const character = element.textContent;
+  if (
+    // @ts-expect-error: TypeScript is wrong that `textContent` on elements can
+    // yield `null`.
+    character.charCodeAt(character.length - 1) === 59 && value !== "semi"
+  ) {
+    return false;
+  }
+  return character === characterReference ? false : character;
+}
+exports.decodeNamedCharacterReference = decodeNamedCharacterReference;

package/dist/node_modules/decode-named-character-reference/index.dom.js

@@ -0,0 +1,17 @@
+const element = document.createElement("i");
+function decodeNamedCharacterReference(value) {
+  const characterReference = "&" + value + ";";
+  element.innerHTML = characterReference;
+  const character = element.textContent;
+  if (
+    // @ts-expect-error: TypeScript is wrong that `textContent` on elements can
+    // yield `null`.
+    character.charCodeAt(character.length - 1) === 59 && value !== "semi"
+  ) {
+    return false;
+  }
+  return character === characterReference ? false : character;
+}
+export {
+  decodeNamedCharacterReference
+};

package/dist/node_modules/devlop/lib/default.cjs

@@ -0,0 +1,7 @@
+"use strict";
+function ok() {
+}
+function unreachable() {
+}
+exports.ok = ok;
+exports.unreachable = unreachable;

package/dist/node_modules/devlop/lib/default.js

@@ -0,0 +1,8 @@
+function ok() {
+}
+function unreachable() {
+}
+export {
+  ok,
+  unreachable
+};

package/dist/node_modules/engine.io-client/build/esm/contrib/has-cors.cjs

@@ -0,0 +1,8 @@
+"use strict";
+let value = false;
+try {
+  value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
+} catch (err) {
+}
+const hasCORS = value;
+exports.hasCORS = hasCORS;

package/dist/node_modules/engine.io-client/build/esm/contrib/has-cors.js

@@ -0,0 +1,9 @@
+let value = false;
+try {
+  value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
+} catch (err) {
+}
+const hasCORS = value;
+export {
+  hasCORS
+};

package/dist/node_modules/engine.io-client/build/esm/contrib/parseqs.cjs

@@ -0,0 +1,23 @@
+"use strict";
+function encode(obj) {
+  let str = "";
+  for (let i in obj) {
+    if (obj.hasOwnProperty(i)) {
+      if (str.length)
+        str += "&";
+      str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
+    }
+  }
+  return str;
+}
+function decode(qs) {
+  let qry = {};
+  let pairs = qs.split("&");
+  for (let i = 0, l = pairs.length; i < l; i++) {
+    let pair = pairs[i].split("=");
+    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+  }
+  return qry;
+}
+exports.decode = decode;
+exports.encode = encode;

package/dist/node_modules/engine.io-client/build/esm/contrib/parseqs.js

@@ -0,0 +1,24 @@
+function encode(obj) {
+  let str = "";
+  for (let i in obj) {
+    if (obj.hasOwnProperty(i)) {
+      if (str.length)
+        str += "&";
+      str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
+    }
+  }
+  return str;
+}
+function decode(qs) {
+  let qry = {};
+  let pairs = qs.split("&");
+  for (let i = 0, l = pairs.length; i < l; i++) {
+    let pair = pairs[i].split("=");
+    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+  }
+  return qry;
+}
+export {
+  decode,
+  encode
+};