@multiplatform.one/components 1.0.0 → 1.0.2

package/dist/cjs/mdx/hooks/useCompileMdx.native.js

@@ -26,49 +26,278 @@ __export(useCompileMdx_exports, {
 });
 module.exports = __toCommonJS(useCompileMdx_exports);
 var import_react = require("react");
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
 function useCompileMdx(source, options) {
-  const [code, setCode] = (0, import_react.useState)(), [frontmatter, setFrontmatter] = (0, import_react.useState)();
-  return (0, import_react.useEffect)(() => {
-    (async () => {
-      const [
-        { compile },
-        { default: grayMatter },
-        { default: rehypeAutolinkHeadings },
-        { default: rehypeSlug },
-        { default: remarkFrontmatter },
-        { default: remarkMdxFrontmatter },
-        { rehypeHighlightCode },
-        { rehypeMetaAttributes }
-      ] = await Promise.all([
-        import("@mdx-js/mdx"),
-        import("gray-matter"),
-        import("rehype-autolink-headings"),
-        import("rehype-slug"),
-        import("remark-frontmatter"),
-        import("remark-mdx-frontmatter"),
-        import("../util/rehypeHighlightCode"),
-        import("../util/rehypeMetaAttributes")
-      ]), { value } = await compile(source, {
-        ...options,
-        development: !1,
-        outputFormat: "function-body",
-        useDynamicImport: !0,
-        remarkPlugins: [
-          ...(options == null ? void 0 : options.remarkPlugins) || [],
-          [remarkMdxFrontmatter, { name: "frontmatter" }],
-          remarkFrontmatter
-        ],
-        rehypePlugins: [
-          ...(options == null ? void 0 : options.rehypePlugins) || [],
-          rehypeAutolinkHeadings,
-          rehypeHighlightCode,
-          rehypeMetaAttributes,
-          rehypeSlug
-        ]
+  var _useState = _sliced_to_array((0, import_react.useState)(), 2), code = _useState[0], setCode = _useState[1], _useState1 = _sliced_to_array((0, import_react.useState)(), 2), frontmatter = _useState1[0], setFrontmatter = _useState1[1];
+  return (0, import_react.useEffect)(function() {
+    _async_to_generator(function() {
+      var _ref, compile, _ref_, grayMatter, _ref_1, rehypeAutolinkHeadings, _ref_2, rehypeSlug, _ref_3, remarkFrontmatter, _ref_4, remarkMdxFrontmatter, rehypeHighlightCode, rehypeMetaAttributes, value;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              Promise.all([
+                import("@mdx-js/mdx"),
+                import("gray-matter"),
+                import("rehype-autolink-headings"),
+                import("rehype-slug"),
+                import("remark-frontmatter"),
+                import("remark-mdx-frontmatter"),
+                import("../util/rehypeHighlightCode"),
+                import("../util/rehypeMetaAttributes")
+              ])
+            ];
+          case 1:
+            return _ref = _sliced_to_array.apply(void 0, [
+              _state.sent(),
+              8
+            ]), compile = _ref[0].compile, _ref_ = _ref[1], grayMatter = _ref_.default, _ref_1 = _ref[2], rehypeAutolinkHeadings = _ref_1.default, _ref_2 = _ref[3], rehypeSlug = _ref_2.default, _ref_3 = _ref[4], remarkFrontmatter = _ref_3.default, _ref_4 = _ref[5], remarkMdxFrontmatter = _ref_4.default, rehypeHighlightCode = _ref[6].rehypeHighlightCode, rehypeMetaAttributes = _ref[7].rehypeMetaAttributes, [
+              4,
+              compile(source, _object_spread_props(_object_spread({}, options), {
+                development: !1,
+                outputFormat: "function-body",
+                // useDynamicImport: true,
+                remarkPlugins: _to_consumable_array((options == null ? void 0 : options.remarkPlugins) || []).concat([
+                  [
+                    remarkMdxFrontmatter,
+                    {
+                      name: "frontmatter"
+                    }
+                  ],
+                  remarkFrontmatter
+                ]),
+                rehypePlugins: _to_consumable_array((options == null ? void 0 : options.rehypePlugins) || []).concat([
+                  rehypeAutolinkHeadings,
+                  rehypeHighlightCode,
+                  rehypeMetaAttributes,
+                  rehypeSlug
+                ])
+              }))
+            ];
+          case 2:
+            return value = _state.sent().value, setCode(value.toString()), setFrontmatter(grayMatter(source)), [
+              2
+            ];
+        }
       });
-      setCode(value.toString()), setFrontmatter(grayMatter(source));
     })();
-  }, [source, options]), !code || !frontmatter ? {} : { code, frontmatter };
+  }, [
+    source,
+    options
+  ]), !code || !frontmatter ? {} : {
+    code,
+    frontmatter
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/mdx/hooks/useCompileMdx.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../src/mdx/hooks/useCompileMdx.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAoC;AAE7B,SAAS,cACd,QACA,SAIA;AACA,QAAM,CAAC,MAAM,OAAO,QAAI,uBAA6B,GAC/C,CAAC,aAAa,cAAc,QAAI,uBAA0C;AA8ChF,aA5CA,wBAAU,MAAM;AACd,KAAC,YAAY;AACX,YAAM;AAAA,QACJ,EAAE,QAAQ;AAAA,QACV,EAAE,SAAS,WAAW;AAAA,QACtB,EAAE,SAAS,uBAAuB;AAAA,QAClC,EAAE,SAAS,WAAW;AAAA,QACtB,EAAE,SAAS,kBAAkB;AAAA,QAC7B,EAAE,SAAS,qBAAqB;AAAA,QAChC,EAAE,oBAAoB;AAAA,QACtB,EAAE,qBAAqB;AAAA,MACzB,IAAI,MAAM,QAAQ,IAAI;AAAA,QACpB,OAAO,aAAa;AAAA,QACpB,OAAO,aAAa;AAAA,QACpB,OAAO,0BAA0B;AAAA,QACjC,OAAO,aAAa;AAAA,QACpB,OAAO,oBAAoB;AAAA,QAC3B,OAAO,wBAAwB;AAAA,QAC/B,OAAO,6BAA6B;AAAA,QACpC,OAAO,8BAA8B;AAAA,MACvC,CAAC,GACK,EAAE,MAAM,IAAI,MAAM,QAAQ,QAAQ;AAAA,QACtC,GAAG;AAAA,QACH,aAAa;AAAA,QACb,cAAc;AAAA,QACd,kBAAkB;AAAA,QAClB,eAAe;AAAA,UACb,IAAI,mCAAS,kBAAiB,CAAC;AAAA,UAC/B,CAAC,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAAA,UAC9C;AAAA,QACF;AAAA,QACA,eAAe;AAAA,UACb,IAAI,mCAAS,kBAAiB,CAAC;AAAA,UAC/B;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF,CAAC;AACD,cAAQ,MAAM,SAAS,CAAC,GACxB,eAAe,WAAW,MAAM,CAAC;AAAA,IACnC,GAAG;AAAA,EACL,GAAG,CAAC,QAAQ,OAAO,CAAC,GAEhB,CAAC,QAAQ,CAAC,cAAoB,CAAC,IAC5B,EAAE,MAAM,YAAY;AAC7B;",
-  "names": []
+  "sources": ["../../../../src/mdx/hooks/Users/clayrisser/Projects/.bitspur/multiplatform.one/packages/components/src/mdx/hooks/useCompileMdx.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAqBA,mBAAoC;AAFnC,SAAA,qBAAA,KAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIM,SAASA,cACdC,QACAC,SAA6B;AAK7B,MAAwBC,YAAAA,qBAAAA,uBAAAA,GAAAA,CAAAA,GAAjBC,OAAiBD,UAAAA,CAAAA,GAAXE,UAAWF,UAAAA,CAAAA,GACcA,aAAAA,qBAAAA,uBAAAA,GAAAA,CAAAA,GAA/BG,cAA+BH,WAAAA,CAAAA,GAAlBI,iBAAkBJ,WAAAA,CAAAA;AA8CtC,aA5CAK,wBAAU,WAAA;AACP,wBAAA,WAAA;UAUK,MARAC,SAAAA,OACSC,YAAAA,QACAC,wBAAAA,QACAC,YAAAA,QACAC,mBAAAA,QACAC,sBACTC,qBACAC,sBAWIC;;;;AAVJ,mBAAA;;cAAMC,QAAQC,IAAG;gBACnB,OAAO,aAAA;gBACP,OAAO,aAAA;gBACP,OAAO,0BAAA;gBACP,OAAO,aAAA;gBACP,OAAO,oBAAA;gBACP,OAAO,wBAAA;gBACP,OAAO,6BAAA;gBACP,OAAO,8BAAA;;;;AARL,0BAAA,iBAAA,MAAA,QAAA;cAAA,OAAA,KAAA;;gBARAV,UAQA,KAAA,CAAA,EARAA,SAAAA,QAQA,KAAA,CAAA,GAPSC,aAAAA,MAATU,SAAAA,SAOA,KAAA,CAAA,GANST,yBAAAA,OAATS,SAAAA,SAMA,KAAA,CAAA,GALSR,aAAAA,OAATQ,SAAAA,SAKA,KAAA,CAAA,GAJSP,oBAAAA,OAATO,SAAAA,SAIA,KAAA,CAAA,GAHSN,uBAAAA,OAATM,SACAL,sBAEA,KAAA,CAAA,EAFAA,qBACAC,uBACA,KAAA,CAAA,EADAA,sBAWc;;cAAMP,QAAQR,QAAQ,qBAAA,eAAA,CAAA,GACnCC,OAAAA,GAAAA;gBACHmB,aAAa;gBACbC,cAAc;;gBAEdC,eACE,sBAAIrB,WAAAA,OAAAA,SAAAA,QAASqB,kBAAa,CAAA,CAAA,EAAA,OAAA;;oBACzBT;oBAAsB;sBAAEU,MAAM;oBAAc;;kBAC7CX;;gBAEFY,eACE,sBAAIvB,WAAAA,OAAAA,SAAAA,QAASuB,kBAAa,CAAA,CAAA,EAAA,OAAA;kBAC1Bd;kBACAI;kBACAC;kBACAJ;;;;;AAfIK,2BAAU,OAAA,KAAA,EAAVA,OAkBRZ,QAAQY,MAAMS,SAAQ,CAAA,GACtBnB,eAAeG,WAAWT,MAAAA,CAAAA;;;;;IAC5B,CAAA,EAAA;EACF,GAAG;IAACA;IAAQC;GAAQ,GAEhB,CAACE,QAAQ,CAACE,cAAoB,CAAC,IAC5B;IAAEF;IAAME;EAAY;AAC7B;",
+  "names": ["useCompileMdx", "source", "options", "useState", "code", "setCode", "frontmatter", "setFrontmatter", "useEffect", "compile", "grayMatter", "rehypeAutolinkHeadings", "rehypeSlug", "remarkFrontmatter", "remarkMdxFrontmatter", "rehypeHighlightCode", "rehypeMetaAttributes", "value", "Promise", "all", "default", "development", "outputFormat", "remarkPlugins", "name", "rehypePlugins", "toString"]
 }

package/dist/cjs/mdx/hooks/useEvaluateMdx.js

@@ -42,8 +42,4 @@ const AsyncFunction = Object.getPrototypeOf(run).constructor;
 function run(code, options) {
   return new AsyncFunction(String(code))(options);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useEvaluateMdx
-});
 //# sourceMappingURL=useEvaluateMdx.js.map

package/dist/cjs/mdx/hooks/useEvaluateMdx.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/mdx/hooks/useEvaluateMdx.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA4B,uCAG5B,eAAoC;AAE7B,SAAS,eAAe,MAAe,SAA+B;AAC3E,QAAM,CAAC,WAAW,YAAY,QAAI,uBAA8D;AAEhG,qCAAU,MAAM;AACd,IAAK,QACL,aAAa,MAAM,YAAY,MAAM,OAAO,CAAC;AAAA,EAC/C,GAAG,CAAC,MAAM,OAAO,CAAC,GAEX;AACT;AAEA,SAAS,YAAY,MAAc,SAA+B;AAChE,SAAO,IAAI,MAAM;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,EACL,CAAC,EAAE;AACL;AAEA,MAAM,gBAAgB,OAAO,eAAe,GAAG,EAAE;AACjD,SAAS,IAAI,MAAc,SAA8B;AACvD,SAAO,IAAI,cAAc,OAAO,IAAI,CAAC,EAAE,OAAO;AAChD;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,iBAA4B,uCAG5B,eAAoC;AAE7B,SAAS,eAAe,MAAe,SAA+B;AAC3E,QAAM,CAAC,WAAW,YAAY,QAAI,uBAA8D;AAEhG,qCAAU,MAAM;AACd,IAAK,QACL,aAAa,MAAM,YAAY,MAAM,OAAO,CAAC;AAAA,EAC/C,GAAG,CAAC,MAAM,OAAO,CAAC,GAEX;AACT;AAEA,SAAS,YAAY,MAAc,SAA+B;AAChE,SAAO,IAAI,MAAM;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,EACL,CAAC,EAAE;AACL;AAEA,MAAM,gBAAgB,OAAO,eAAe,GAAG,EAAE;AACjD,SAAS,IAAI,MAAc,SAA8B;AACvD,SAAO,IAAI,cAAc,OAAO,IAAI,CAAC,EAAE,OAAO;AAChD;",
   "names": []
 }

package/dist/cjs/mdx/hooks/useEvaluateMdx.native.js

@@ -26,19 +26,87 @@ __export(useEvaluateMdx_exports, {
 });
 module.exports = __toCommonJS(useEvaluateMdx_exports);
 var jsxRuntime = __toESM(require("react/jsx-runtime")), import_react = require("react");
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
 function useEvaluateMdx(code, options) {
-  const [Component, setComponent] = (0, import_react.useState)();
-  return (0, import_react.useEffect)(() => {
-    code && setComponent(() => evaluateMdx(code, options));
-  }, [code, options]), Component;
+  var _useState = _sliced_to_array((0, import_react.useState)(), 2), Component = _useState[0], setComponent = _useState[1];
+  return (0, import_react.useEffect)(function() {
+    code && setComponent(function() {
+      return evaluateMdx(code, options);
+    });
+  }, [
+    code,
+    options
+  ]), Component;
 }
 function evaluateMdx(code, options) {
-  return run(code, {
-    ...jsxRuntime,
-    ...options
-  }).default;
+  return run(code, _object_spread({}, jsxRuntime, options)).default;
 }
-const AsyncFunction = Object.getPrototypeOf(run).constructor;
+var AsyncFunction = Object.getPrototypeOf(run).constructor;
 function run(code, options) {
   return new AsyncFunction(String(code))(options);
 }

package/dist/cjs/mdx/hooks/useEvaluateMdx.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../src/mdx/hooks/useEvaluateMdx.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA4B,uCAG5B,eAAoC;AAE7B,SAAS,eAAe,MAAe,SAA+B;AAC3E,QAAM,CAAC,WAAW,YAAY,QAAI,uBAA8D;AAEhG,qCAAU,MAAM;AACd,IAAK,QACL,aAAa,MAAM,YAAY,MAAM,OAAO,CAAC;AAAA,EAC/C,GAAG,CAAC,MAAM,OAAO,CAAC,GAEX;AACT;AAEA,SAAS,YAAY,MAAc,SAA+B;AAChE,SAAO,IAAI,MAAM;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,EACL,CAAC,EAAE;AACL;AAEA,MAAM,gBAAgB,OAAO,eAAe,GAAG,EAAE;AACjD,SAAS,IAAI,MAAc,SAA8B;AACvD,SAAO,IAAI,cAAc,OAAO,IAAI,CAAC,EAAE,OAAO;AAChD;",
-  "names": []
+  "sources": ["../../../../src/mdx/hooks/Users/clayrisser/Projects/.bitspur/multiplatform.one/packages/components/src/mdx/hooks/useEvaluateMdx.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAqBA,iBAA4B,uCAG5B,eAAoC;AALnC,SAAA,qBAAA,KAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOM,SAASA,eAAeC,MAAeC,SAA6B;AACzE,MAAkCC,YAAAA,qBAAAA,uBAAAA,GAAAA,CAAAA,GAA3BC,YAA2BD,UAAAA,CAAAA,GAAhBE,eAAgBF,UAAAA,CAAAA;AAElCG,qCAAU,WAAA;AACR,IAAKL,QACLI,aAAa,WAAA;aAAME,YAAYN,MAAMC,OAAAA;;EACvC,GAAG;IAACD;IAAMC;GAAQ,GAEXE;AACT;AAEA,SAASG,YAAYN,MAAcC,SAA6B;AAC9D,SAAOM,IAAIP,MAAM,eAAA,CAAA,GACZQ,YACAP,OAAAA,CAAAA,EACFQ;AACL;AAEA,IAAMC,gBAAgBC,OAAOC,eAAeL,GAAAA,EAAKM;AACjD,SAASN,IAAIP,MAAcC,SAA4B;AACrD,SAAO,IAAIS,cAAcI,OAAOd,IAAAA,CAAAA,EAAOC,OAAAA;AACzC;",
+  "names": ["useEvaluateMdx", "code", "options", "useState", "Component", "setComponent", "useEffect", "evaluateMdx", "run", "jsxRuntime", "default", "AsyncFunction", "Object", "getPrototypeOf", "constructor", "String"]
 }

package/dist/cjs/mdx/index.js

@@ -19,15 +19,4 @@ __reExport(mdx_exports, require("./MDXCodeBlock"), module.exports);
 __reExport(mdx_exports, require("./UL"), module.exports);
 __reExport(mdx_exports, require("./components"), module.exports);
 __reExport(mdx_exports, require("./hooks"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./ExternalIcon"),
-  ...require("./HR"),
-  ...require("./LI"),
-  ...require("./MDX"),
-  ...require("./MDXCodeBlock"),
-  ...require("./UL"),
-  ...require("./components"),
-  ...require("./hooks")
-});
 //# sourceMappingURL=index.js.map

package/dist/cjs/mdx/index.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../src/mdx/index.ts"],
-  "mappings": ";;;;;;;;;;;AAAA;AAAA;AAAA,wBAAc,2BAAd;AACA,wBAAc,iBADd;AAEA,wBAAc,iBAFd;AAGA,wBAAc,kBAHd;AAIA,wBAAc,2BAJd;AAKA,wBAAc,iBALd;AAMA,wBAAc,yBANd;AAOA,wBAAc,oBAPd;",
+  "sources": ["../../../src/mdx/Users/clayrisser/Projects/.bitspur/multiplatform.one/packages/components/src/mdx/index.ts"],
+  "mappings": ";;;;;;;;;;;AAAA;;wBAAc,2BAAd;AACA,wBAAc,iBADd;AAEA,wBAAc,iBAFd;AAGA,wBAAc,kBAHd;AAIA,wBAAc,2BAJd;AAKA,wBAAc,iBALd;AAMA,wBAAc,yBANd;AAOA,wBAAc,oBAPd;",
   "names": []
 }

package/dist/cjs/mdx/util/rehypeHighlightCode.js

@@ -40,8 +40,4 @@ function rehypeHighlightCode(_options = {}) {
     (0, import_unist_util_visit.visit)(tree, "element", visitor);
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  rehypeHighlightCode
-});
 //# sourceMappingURL=rehypeHighlightCode.js.map

package/dist/cjs/mdx/util/rehypeHighlightCode.native.js

@@ -26,17 +26,63 @@ __export(rehypeHighlightCode_exports, {
 });
 module.exports = __toCommonJS(rehypeHighlightCode_exports);
 var import_parse_numeric_range = __toESM(require("parse-numeric-range")), import_tsx = __toESM(require("refractor/lang/tsx")), import_refractor = require("refractor"), import_rehypeHighlightLine = require("./rehypeHighlightLine"), import_rehypeHighlightWord = require("./rehypeHighlightWord"), import_hast_util_to_string = require("hast-util-to-string"), import_unist_util_visit = require("unist-util-visit");
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
 import_refractor.refractor.register(import_tsx.default);
-function rehypeHighlightCode(_options = {}) {
+function rehypeHighlightCode() {
+  var _options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   function visitor(node, index, parent) {
-    if (!parent || parent.tagName !== "pre" || node.tagName !== "code" || !node.properties.className)
-      return;
-    const [, lang] = node.properties.className[0].split("-"), codeString = (0, import_hast_util_to_string.toString)(node);
-    let result = import_refractor.refractor.highlight(codeString, lang);
-    const linesToHighlight = (0, import_parse_numeric_range.default)(node.properties.line || "0");
-    result = (0, import_rehypeHighlightLine.rehypeHighlightLine)(result, linesToHighlight), node.children = (0, import_rehypeHighlightWord.rehypeHighlightWord)(result);
+    if (!(!parent || parent.tagName !== "pre" || node.tagName !== "code" || !node.properties.className)) {
+      var _node_properties_className__split = _sliced_to_array(node.properties.className[0].split("-"), 2), lang = _node_properties_className__split[1], codeString = (0, import_hast_util_to_string.toString)(node), result = import_refractor.refractor.highlight(codeString, lang), linesToHighlight = (0, import_parse_numeric_range.default)(node.properties.line || "0");
+      result = (0, import_rehypeHighlightLine.rehypeHighlightLine)(result, linesToHighlight), node.children = (0, import_rehypeHighlightWord.rehypeHighlightWord)(result);
+    }
   }
-  return (tree) => {
+  return function(tree) {
     (0, import_unist_util_visit.visit)(tree, "element", visitor);
   };
 }

package/dist/cjs/mdx/util/rehypeHighlightCode.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../src/mdx/util/rehypeHighlightCode.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iCAAwB,yCACxB,aAAgB,wCAChB,mBAA0B,sBAC1B,6BAAoC,kCACpC,6BAAoC,kCACpC,6BAAyB,gCACzB,0BAAsB;AAEtB,2BAAU,SAAS,WAAAA,OAAG;AAEf,SAAS,oBAAoB,WAAW,CAAC,GAAG;AACjD,WAAS,QAAQ,MAAW,OAAY,QAAa;AACnD,QAAI,CAAC,UAAU,OAAO,YAAY,SAAS,KAAK,YAAY,UAAU,CAAC,KAAK,WAAW;AACrF;AAEF,UAAM,CAAC,EAAE,IAAI,IAAI,KAAK,WAAW,UAAU,CAAC,EAAE,MAAM,GAAG,GACjD,iBAAa,qCAAS,IAAI;AAChC,QAAI,SAAS,2BAAU,UAAU,YAAY,IAAI;AACjD,UAAM,uBAAmB,2BAAAC,SAAY,KAAK,WAAW,QAAQ,GAAG;AAChE,iBAAS,gDAAoB,QAAQ,gBAAgB,GACrD,KAAK,eAAW,gDAAoB,MAAM;AAAA,EAC5C;AACA,SAAO,CAAC,SAAc;AACpB,uCAAM,MAAM,WAAW,OAAO;AAAA,EAChC;AACF;",
-  "names": ["tsx", "rangeParser"]
+  "sources": ["../../../../src/mdx/util/Users/clayrisser/Projects/.bitspur/multiplatform.one/packages/components/src/mdx/util/rehypeHighlightCode.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAEA,iCAAwB,yCACxB,aAAgB,wCAChB,mBAA0B,sBAC1B,6BAAoC,kCACpC,6BAAoC,kCACpC,6BAAyB,gCACzB,0BAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtBA,2BAAUC,SAASC,WAAAA,OAAAA;AAEZ,SAASC,sBAAAA;MAAoBC,WAAAA,UAAAA,SAAAA,KAAAA,UAAAA,CAAAA,MAAAA,SAAAA,UAAAA,CAAAA,IAAW,CAAC;AAC9C,WAASC,QAAQC,MAAWC,OAAYC,QAAW;AACjD,QAAI,GAACA,UAAUA,OAAOC,YAAY,SAASH,KAAKG,YAAY,UAAU,CAACH,KAAKI,WAAWC,YAGvF;UAAiBL,oCAAAA,iBAAAA,KAAKI,WAAWC,UAAU,CAAA,EAAGC,MAAM,GAAA,GAAA,CAAA,GAA3CC,OAAQP,kCAAAA,CAAAA,GACXQ,iBAAaC,qCAAST,IAAAA,GACxBU,SAAShB,2BAAUiB,UAAUH,YAAYD,IAAAA,GACvCK,uBAAmBC,2BAAAA,SAAYb,KAAKI,WAAWU,QAAQ,GAAA;AAC7DJ,mBAASK,gDAAoBL,QAAQE,gBAAAA,GACrCZ,KAAKgB,eAAWC,gDAAoBP,MAAAA;;EACtC;AACA,SAAO,SAACQ,MAAAA;AACNC,uCAAMD,MAAM,WAAWnB,OAAAA;EACzB;AACF;",
+  "names": ["refractor", "register", "tsx", "rehypeHighlightCode", "_options", "visitor", "node", "index", "parent", "tagName", "properties", "className", "split", "lang", "codeString", "toString", "result", "highlight", "linesToHighlight", "rangeParser", "line", "rehypeHighlightLine", "children", "rehypeHighlightWord", "tree", "visit"]
 }

package/dist/cjs/mdx/util/rehypeHighlightLine.js

@@ -98,8 +98,4 @@ function applyMultilineFix(ast) {
 <span class="token ${token}">`)
   ), (0, import_unified.unified)().use(import_rehype_parse.default, { emitParseErrors: !0, fragment: !0 }).parse(html).children;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  rehypeHighlightLine
-});
 //# sourceMappingURL=rehypeHighlightLine.js.map

package/dist/cjs/mdx/util/rehypeHighlightLine.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../../src/mdx/util/rehypeHighlightLine.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,0BAAkB,kCAClB,2BAAuB,8BACvB,iBAAwB;AAEjB,SAAS,oBAAoB,KAAU,OAAc;AAC1D,QAAM,eAAe,kBAAkB,GAAG,GACpC,WAAW,cAAc,YAAY,EAAE;AAC7C,SAAO,UAAU,UAAU,KAAK;AAClC;AAEA,SAAS,cAAc,KAAU,UAAU,GAAG;AAC5C,MAAI,aAAa;AACjB,SAAO,IAAI;AAAA,IACT,CAAC,QAAa,SAAc;AAC1B,UAAI,KAAK,SAAS,QAAQ;AACxB,YAAI,KAAK,MAAM,QAAQ;AAAA,CAAI,MAAM;AAC/B,sBAAK,aAAa,YAClB,OAAO,MAAM,KAAK,IAAI,GACf;AAET,cAAM,QAAQ,KAAK,MAAM,MAAM;AAAA,CAAI;AACnC,iBAAS,IAAI,GAAG,IAAI,MAAM,QAAQ;AAEhC,UADI,MAAM,KAAG,EAAE,YACX,QAAM,MAAM,SAAS,KAAK,MAAM,CAAC,EAAE,WAAW,MAClD,OAAO,MAAM,KAAK;AAAA,YAChB,MAAM;AAAA,YACN,OAAO,MAAM,MAAM,SAAS,IAAI,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;AAAA;AAAA,YACtD;AAAA,UACF,CAAC;AAEH,sBAAO,aAAa,YACb;AAAA,MACT;AACA,UAAI,KAAK,UAAU;AACjB,aAAK,aAAa;AAClB,cAAM,YAAY,cAAc,KAAK,UAAU,UAAU;AACzD,oBAAK,WAAW,UAAU,OAC1B,OAAO,aAAa,UAAU,YAC9B,OAAO,MAAM,KAAK,IAAI,GACf;AAAA,MACT;AACA,oBAAO,MAAM,KAAK,IAAI,GACf;AAAA,IACT;AAAA,IACA,EAAE,OAAO,CAAC,GAAG,WAAuB;AAAA,EACtC;AACF;AAEA,SAAS,UAAU,KAAY,kBAAuB;AACpD,QAAM,eAAe,iBAAiB,WAAW,KAAK,iBAAiB,CAAC,MAAM,GACxE,WAAkB,MAAM,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACxE,MAAI,IAAI;AA8BR,SA7BgB,SAAS,OAAO,CAAC,OAAO,WAAW;AACjD,UAAM,OAAO,QACP,WAAkB,CAAC;AACzB,WAAO,IAAI,IAAI,QAAQ,KAAK;AAC1B,UAAI,IAAI,CAAC,EAAE,aAAa,MAAM;AAC5B,cAAM,KAAK,IAAI,CAAC,CAAC;AACjB;AAAA,MACF;AACA,UAAI,IAAI,CAAC,EAAE,eAAe,MAAM;AAC9B,iBAAS,KAAK,IAAI,CAAC,CAAC;AACpB;AAAA,MACF;AACA,UAAI,IAAI,CAAC,EAAE,aAAa;AACtB;AAAA,IAEJ;AACA,iBAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,SAAS;AAAA,MACT,YAAY;AAAA,QACV,UAAU;AAAA,QACV,WAAW;AAAA,QACX,iBAAiB,iBAAiB,SAAS,IAAI,KAAK,eAAe,SAAS;AAAA,MAC9E;AAAA,MACA;AAAA,MACA,YAAY;AAAA,IACd,CAAC,GACM;AAAA,EACT,GAAG,CAAC,CAAC;AAEP;AAGA,MAAM,uBAAuB;AAE7B,SAAS,kBAAkB,KAAU;AAEnC,MAAI,WAAO,iCAAO,GAAG;AAErB,gBAAO,KAAK;AAAA,IAAQ;AAAA,IAAsB,CAAC,OAAO,UAChD,MAAM,QAAQ,OAAO;AAAA,qBAA+B,KAAK,IAAI;AAAA,EAC/D,OAEa,wBAAQ,EAAE,IAAI,oBAAAA,SAAO,EAAE,iBAAiB,IAAM,UAAU,GAAK,CAAC,EAAE,MAAM,IAAI,EAC3E;AACd;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,0BAAkB,kCAClB,2BAAuB,8BACvB,iBAAwB;AAEjB,SAAS,oBAAoB,KAAU,OAAc;AAC1D,QAAM,eAAe,kBAAkB,GAAG,GACpC,WAAW,cAAc,YAAY,EAAE;AAC7C,SAAO,UAAU,UAAU,KAAK;AAClC;AAEA,SAAS,cAAc,KAAU,UAAU,GAAG;AAC5C,MAAI,aAAa;AACjB,SAAO,IAAI;AAAA,IACT,CAAC,QAAa,SAAc;AAC1B,UAAI,KAAK,SAAS,QAAQ;AACxB,YAAI,KAAK,MAAM,QAAQ;AAAA,CAAI,MAAM;AAC/B,sBAAK,aAAa,YAClB,OAAO,MAAM,KAAK,IAAI,GACf;AAET,cAAM,QAAQ,KAAK,MAAM,MAAM;AAAA,CAAI;AACnC,iBAAS,IAAI,GAAG,IAAI,MAAM,QAAQ;AAEhC,UADI,MAAM,KAAG,EAAE,YACX,QAAM,MAAM,SAAS,KAAK,MAAM,CAAC,EAAE,WAAW,MAClD,OAAO,MAAM,KAAK;AAAA,YAChB,MAAM;AAAA,YACN,OAAO,MAAM,MAAM,SAAS,IAAI,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;AAAA;AAAA,YACtD;AAAA,UACF,CAAC;AAEH,sBAAO,aAAa,YACb;AAAA,MACT;AACA,UAAI,KAAK,UAAU;AACjB,aAAK,aAAa;AAClB,cAAM,YAAY,cAAc,KAAK,UAAU,UAAU;AACzD,oBAAK,WAAW,UAAU,OAC1B,OAAO,aAAa,UAAU,YAC9B,OAAO,MAAM,KAAK,IAAI,GACf;AAAA,MACT;AACA,oBAAO,MAAM,KAAK,IAAI,GACf;AAAA,IACT;AAAA,IACA,EAAE,OAAO,CAAC,GAAG,WAAuB;AAAA,EACtC;AACF;AAEA,SAAS,UAAU,KAAY,kBAAuB;AACpD,QAAM,eAAe,iBAAiB,WAAW,KAAK,iBAAiB,CAAC,MAAM,GACxE,WAAkB,MAAM,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AACxE,MAAI,IAAI;AA8BR,SA7BgB,SAAS,OAAO,CAAC,OAAO,WAAW;AACjD,UAAM,OAAO,QACP,WAAkB,CAAC;AACzB,WAAO,IAAI,IAAI,QAAQ,KAAK;AAC1B,UAAI,IAAI,CAAC,EAAE,aAAa,MAAM;AAC5B,cAAM,KAAK,IAAI,CAAC,CAAC;AACjB;AAAA,MACF;AACA,UAAI,IAAI,CAAC,EAAE,eAAe,MAAM;AAC9B,iBAAS,KAAK,IAAI,CAAC,CAAC;AACpB;AAAA,MACF;AACA,UAAI,IAAI,CAAC,EAAE,aAAa;AACtB;AAAA,IAEJ;AACA,iBAAM,KAAK;AAAA,MACT,MAAM;AAAA,MACN,SAAS;AAAA,MACT,YAAY;AAAA,QACV,UAAU;AAAA,QACV,WAAW;AAAA,QACX,iBAAiB,iBAAiB,SAAS,IAAI,KAAK,eAAe,SAAS;AAAA,MAC9E;AAAA,MACA;AAAA,MACA,YAAY;AAAA,IACd,CAAC,GACM;AAAA,EACT,GAAG,CAAC,CAAC;AAEP;AAGA,MAAM,uBAAuB;AAE7B,SAAS,kBAAkB,KAAU;AAEnC,MAAI,WAAO,iCAAO,GAAG;AAErB,gBAAO,KAAK;AAAA,IAAQ;AAAA,IAAsB,CAAC,OAAO,UAChD,MAAM,QAAQ,OAAO;AAAA,qBAA+B,KAAK,IAAI;AAAA,EAC/D,OAEa,wBAAQ,EAClB,IAAI,oBAAAA,SAAc,EAAE,iBAAiB,IAAM,UAAU,GAAK,CAAC,EAC3D,MAAM,IAAI,EACQ;AACvB;",
   "names": ["parse"]
 }