storybook 10.1.0-alpha.9 → 10.1.0-beta.0

package/dist/_node-chunks/{chunk-SGM3ZCCT.js → chunk-EVK2SBW5.js}

@@ -1,251 +1,150 @@
-import CJS_COMPAT_NODE_URL_jpweijb0qqj from 'node:url';
-import CJS_COMPAT_NODE_PATH_jpweijb0qqj from 'node:path';
-import CJS_COMPAT_NODE_MODULE_jpweijb0qqj from "node:module";
+import CJS_COMPAT_NODE_URL_hjmvusgt1gv from 'node:url';
+import CJS_COMPAT_NODE_PATH_hjmvusgt1gv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_hjmvusgt1gv from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_jpweijb0qqj.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_jpweijb0qqj.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_jpweijb0qqj.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_hjmvusgt1gv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_hjmvusgt1gv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_hjmvusgt1gv.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
-  __name,
   __require
-} from "./chunk-3THWHQOC.js";
+} from "./chunk-UFOFO5H7.js";
 
 // ../node_modules/@storybook/docs-mdx/dist/chunk-H6DQNFQR.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require2 = ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: /* @__PURE__ */ __name((a, b) => (typeof __require !== "undefined" ? __require : a)[b], "get")
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __require2 = ((x) => typeof __require < "u" ? __require : typeof Proxy < "u" ? new Proxy(x, {
+  get: (a, b) => (typeof __require < "u" ? __require : a)[b]
 }) : x)(function(x) {
-  if (typeof __require !== "undefined")
+  if (typeof __require < "u")
     return __require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = /* @__PURE__ */ __name((cb, mod) => /* @__PURE__ */ __name(function __require22() {
+}), __commonJS = (cb, mod) => function() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-}, "__require2"), "__commonJS");
-var __export = /* @__PURE__ */ __name((target, all2) => {
+}, __export = (target, all2) => {
   for (var name2 in all2)
-    __defProp(target, name2, { get: all2[name2], enumerable: true });
-}, "__export");
-var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+    __defProp(target, name2, { get: all2[name2], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
-}, "__copyProps");
-var __toESM = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+}, __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
-)), "__toESM");
-var require_inline_style_parser = __commonJS({
+)), require_inline_style_parser = __commonJS({
   "node_modules/inline-style-parser/index.js"(exports, module) {
-    var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
-    var NEWLINE_REGEX = /\n/g;
-    var WHITESPACE_REGEX = /^\s*/;
-    var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
-    var COLON_REGEX = /^:\s*/;
-    var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
-    var SEMICOLON_REGEX = /^[;\s]*/;
-    var TRIM_REGEX = /^\s+|\s+$/g;
-    var NEWLINE = "\n";
-    var FORWARD_SLASH = "/";
-    var ASTERISK = "*";
-    var EMPTY_STRING = "";
-    var TYPE_COMMENT = "comment";
-    var TYPE_DECLARATION = "declaration";
+    var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g, NEWLINE_REGEX = /\n/g, WHITESPACE_REGEX = /^\s*/, PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/, COLON_REGEX = /^:\s*/, VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/, SEMICOLON_REGEX = /^[;\s]*/, TRIM_REGEX = /^\s+|\s+$/g, NEWLINE = `
+`, FORWARD_SLASH = "/", ASTERISK = "*", EMPTY_STRING = "", TYPE_COMMENT = "comment", TYPE_DECLARATION = "declaration";
     module.exports = function(style, options) {
-      if (typeof style !== "string") {
+      if (typeof style != "string")
         throw new TypeError("First argument must be a string");
-      }
       if (!style)
         return [];
       options = options || {};
-      var lineno = 1;
-      var column = 1;
+      var lineno = 1, column = 1;
       function updatePosition(str) {
         var lines = str.match(NEWLINE_REGEX);
-        if (lines)
-          lineno += lines.length;
+        lines && (lineno += lines.length);
         var i = str.lastIndexOf(NEWLINE);
         column = ~i ? str.length - i : column + str.length;
       }
-      __name(updatePosition, "updatePosition");
       function position2() {
         var start2 = { line: lineno, column };
         return function(node) {
-          node.position = new Position(start2);
-          whitespace2();
-          return node;
+          return node.position = new Position(start2), whitespace2(), node;
         };
       }
-      __name(position2, "position2");
       function Position(start2) {
-        this.start = start2;
-        this.end = { line: lineno, column };
-        this.source = options.source;
+        this.start = start2, this.end = { line: lineno, column }, this.source = options.source;
       }
-      __name(Position, "Position");
       Position.prototype.content = style;
       var errorsList = [];
       function error(msg) {
         var err = new Error(
           options.source + ":" + lineno + ":" + column + ": " + msg
         );
-        err.reason = msg;
-        err.filename = options.source;
-        err.line = lineno;
-        err.column = column;
-        err.source = style;
-        if (options.silent) {
+        if (err.reason = msg, err.filename = options.source, err.line = lineno, err.column = column, err.source = style, options.silent)
           errorsList.push(err);
-        } else {
+        else
           throw err;
-        }
       }
-      __name(error, "error");
       function match(re2) {
         var m = re2.exec(style);
-        if (!m)
-          return;
-        var str = m[0];
-        updatePosition(str);
-        style = style.slice(str.length);
-        return m;
+        if (m) {
+          var str = m[0];
+          return updatePosition(str), style = style.slice(str.length), m;
+        }
       }
-      __name(match, "match");
       function whitespace2() {
         match(WHITESPACE_REGEX);
       }
-      __name(whitespace2, "whitespace2");
       function comments(rules) {
         var c;
-        rules = rules || [];
-        while (c = comment2()) {
-          if (c !== false) {
-            rules.push(c);
-          }
-        }
+        for (rules = rules || []; c = comment2(); )
+          c !== !1 && rules.push(c);
         return rules;
       }
-      __name(comments, "comments");
       function comment2() {
         var pos = position2();
-        if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1))
-          return;
-        var i = 2;
-        while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
-          ++i;
-        }
-        i += 2;
-        if (EMPTY_STRING === style.charAt(i - 1)) {
-          return error("End of comment missing");
+        if (!(FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1))) {
+          for (var i = 2; EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1)); )
+            ++i;
+          if (i += 2, EMPTY_STRING === style.charAt(i - 1))
+            return error("End of comment missing");
+          var str = style.slice(2, i - 2);
+          return column += 2, updatePosition(str), style = style.slice(i), column += 2, pos({
+            type: TYPE_COMMENT,
+            comment: str
+          });
         }
-        var str = style.slice(2, i - 2);
-        column += 2;
-        updatePosition(str);
-        style = style.slice(i);
-        column += 2;
-        return pos({
-          type: TYPE_COMMENT,
-          comment: str
-        });
       }
-      __name(comment2, "comment2");
       function declaration() {
-        var pos = position2();
-        var prop = match(PROPERTY_REGEX);
-        if (!prop)
-          return;
-        comment2();
-        if (!match(COLON_REGEX))
-          return error("property missing ':'");
-        var val = match(VALUE_REGEX);
-        var ret = pos({
-          type: TYPE_DECLARATION,
-          property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
-          value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
-        });
-        match(SEMICOLON_REGEX);
-        return ret;
+        var pos = position2(), prop = match(PROPERTY_REGEX);
+        if (prop) {
+          if (comment2(), !match(COLON_REGEX))
+            return error("property missing ':'");
+          var val = match(VALUE_REGEX), ret = pos({
+            type: TYPE_DECLARATION,
+            property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+            value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+          });
+          return match(SEMICOLON_REGEX), ret;
+        }
       }
-      __name(declaration, "declaration");
       function declarations() {
         var decls = [];
         comments(decls);
-        var decl;
-        while (decl = declaration()) {
-          if (decl !== false) {
-            decls.push(decl);
-            comments(decls);
-          }
-        }
+        for (var decl; decl = declaration(); )
+          decl !== !1 && (decls.push(decl), comments(decls));
         return decls;
       }
-      __name(declarations, "declarations");
-      whitespace2();
-      return declarations();
+      return whitespace2(), declarations();
     };
     function trim(str) {
       return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
     }
-    __name(trim, "trim");
   }
-});
-var require_style_to_object = __commonJS({
+}), require_style_to_object = __commonJS({
   "node_modules/style-to-object/index.js"(exports, module) {
     var parse = require_inline_style_parser();
     function StyleToObject2(style, iterator) {
       var output = null;
-      if (!style || typeof style !== "string") {
+      if (!style || typeof style != "string")
         return output;
-      }
-      var declaration;
-      var declarations = parse(style);
-      var hasIterator = typeof iterator === "function";
-      var property;
-      var value;
-      for (var i = 0, len = declarations.length; i < len; i++) {
-        declaration = declarations[i];
-        property = declaration.property;
-        value = declaration.value;
-        if (hasIterator) {
-          iterator(property, value, declaration);
-        } else if (value) {
-          output || (output = {});
-          output[property] = value;
-        }
-      }
+      for (var declaration, declarations = parse(style), hasIterator = typeof iterator == "function", property, value, i = 0, len = declarations.length; i < len; i++)
+        declaration = declarations[i], property = declaration.property, value = declaration.value, hasIterator ? iterator(property, value, declaration) : value && (output || (output = {}), output[property] = value);
       return output;
     }
-    __name(StyleToObject2, "StyleToObject2");
-    module.exports = StyleToObject2;
-    module.exports.default = StyleToObject2;
+    module.exports = StyleToObject2, module.exports.default = StyleToObject2;
   }
 });
-function ok() {
-}
-__name(ok, "ok");
-function unreachable() {
-}
-__name(unreachable, "unreachable");
 var Schema = class {
-  static {
-    __name(this, "Schema");
-  }
   /**
    * @constructor
    * @param {Properties} property
@@ -253,82 +152,56 @@ var Schema = class {
    * @param {string} [space]
    */
   constructor(property, normal, space) {
-    this.property = property;
-    this.normal = normal;
-    if (space) {
-      this.space = space;
-    }
+    this.property = property, this.normal = normal, space && (this.space = space);
   }
 };
 Schema.prototype.property = {};
 Schema.prototype.normal = {};
 Schema.prototype.space = null;
 function merge(definitions, space) {
-  const property = {};
-  const normal = {};
-  let index = -1;
-  while (++index < definitions.length) {
-    Object.assign(property, definitions[index].property);
-    Object.assign(normal, definitions[index].normal);
-  }
+  let property = {}, normal = {}, index = -1;
+  for (; ++index < definitions.length; )
+    Object.assign(property, definitions[index].property), Object.assign(normal, definitions[index].normal);
   return new Schema(property, normal, space);
 }
-__name(merge, "merge");
 function normalize(value) {
   return value.toLowerCase();
 }
-__name(normalize, "normalize");
 var Info = class {
-  static {
-    __name(this, "Info");
-  }
   /**
    * @constructor
    * @param {string} property
    * @param {string} attribute
    */
   constructor(property, attribute) {
-    this.property = property;
-    this.attribute = attribute;
+    this.property = property, this.attribute = attribute;
   }
 };
 Info.prototype.space = null;
-Info.prototype.boolean = false;
-Info.prototype.booleanish = false;
-Info.prototype.overloadedBoolean = false;
-Info.prototype.number = false;
-Info.prototype.commaSeparated = false;
-Info.prototype.spaceSeparated = false;
-Info.prototype.commaOrSpaceSeparated = false;
-Info.prototype.mustUseProperty = false;
-Info.prototype.defined = false;
+Info.prototype.boolean = !1;
+Info.prototype.booleanish = !1;
+Info.prototype.overloadedBoolean = !1;
+Info.prototype.number = !1;
+Info.prototype.commaSeparated = !1;
+Info.prototype.spaceSeparated = !1;
+Info.prototype.commaOrSpaceSeparated = !1;
+Info.prototype.mustUseProperty = !1;
+Info.prototype.defined = !1;
 var types_exports = {};
 __export(types_exports, {
-  boolean: /* @__PURE__ */ __name(() => boolean, "boolean"),
-  booleanish: /* @__PURE__ */ __name(() => booleanish, "booleanish"),
-  commaOrSpaceSeparated: /* @__PURE__ */ __name(() => commaOrSpaceSeparated, "commaOrSpaceSeparated"),
-  commaSeparated: /* @__PURE__ */ __name(() => commaSeparated, "commaSeparated"),
-  number: /* @__PURE__ */ __name(() => number, "number"),
-  overloadedBoolean: /* @__PURE__ */ __name(() => overloadedBoolean, "overloadedBoolean"),
-  spaceSeparated: /* @__PURE__ */ __name(() => spaceSeparated, "spaceSeparated")
+  boolean: () => boolean,
+  booleanish: () => booleanish,
+  commaOrSpaceSeparated: () => commaOrSpaceSeparated,
+  commaSeparated: () => commaSeparated,
+  number: () => number,
+  overloadedBoolean: () => overloadedBoolean,
+  spaceSeparated: () => spaceSeparated
 });
-var powers = 0;
-var boolean = increment();
-var booleanish = increment();
-var overloadedBoolean = increment();
-var number = increment();
-var spaceSeparated = increment();
-var commaSeparated = increment();
-var commaOrSpaceSeparated = increment();
+var powers = 0, boolean = increment(), booleanish = increment(), overloadedBoolean = increment(), number = increment(), spaceSeparated = increment(), commaSeparated = increment(), commaOrSpaceSeparated = increment();
 function increment() {
   return 2 ** ++powers;
 }
-__name(increment, "increment");
-var checks = Object.keys(types_exports);
-var DefinedInfo = class extends Info {
-  static {
-    __name(this, "DefinedInfo");
-  }
+var checks = Object.keys(types_exports), DefinedInfo = class extends Info {
   /**
    * @constructor
    * @param {string} property
@@ -338,48 +211,32 @@ var DefinedInfo = class extends Info {
    */
   constructor(property, attribute, mask, space) {
     let index = -1;
-    super(property, attribute);
-    mark(this, "space", space);
-    if (typeof mask === "number") {
-      while (++index < checks.length) {
-        const check = checks[index];
+    if (super(property, attribute), mark(this, "space", space), typeof mask == "number")
+      for (; ++index < checks.length; ) {
+        let check = checks[index];
         mark(this, checks[index], (mask & types_exports[check]) === types_exports[check]);
       }
-    }
   }
 };
-DefinedInfo.prototype.defined = true;
+DefinedInfo.prototype.defined = !0;
 function mark(values, key, value) {
-  if (value) {
-    values[key] = value;
-  }
+  value && (values[key] = value);
 }
-__name(mark, "mark");
 var own = {}.hasOwnProperty;
 function create(definition) {
-  const property = {};
-  const normal = {};
-  let prop;
-  for (prop in definition.properties) {
+  let property = {}, normal = {}, prop;
+  for (prop in definition.properties)
     if (own.call(definition.properties, prop)) {
-      const value = definition.properties[prop];
-      const info = new DefinedInfo(
+      let value = definition.properties[prop], info = new DefinedInfo(
         prop,
         definition.transform(definition.attributes || {}, prop),
         value,
         definition.space
       );
-      if (definition.mustUseProperty && definition.mustUseProperty.includes(prop)) {
-        info.mustUseProperty = true;
-      }
-      property[prop] = info;
-      normal[normalize(prop)] = prop;
-      normal[normalize(info.attribute)] = prop;
+      definition.mustUseProperty && definition.mustUseProperty.includes(prop) && (info.mustUseProperty = !0), property[prop] = info, normal[normalize(prop)] = prop, normal[normalize(info.attribute)] = prop;
     }
-  }
   return new Schema(property, normal, definition.space);
 }
-__name(create, "create");
 var xlink = create({
   space: "xlink",
   transform(_, prop) {
@@ -394,8 +251,7 @@ var xlink = create({
     xLinkTitle: null,
     xLinkType: null
   }
-});
-var xml = create({
+}), xml = create({
   space: "xml",
   transform(_, prop) {
     return "xml:" + prop.slice(3).toLowerCase();
@@ -405,18 +261,15 @@ var xml = create({
 function caseSensitiveTransform(attributes, attribute) {
   return attribute in attributes ? attributes[attribute] : attribute;
 }
-__name(caseSensitiveTransform, "caseSensitiveTransform");
 function caseInsensitiveTransform(attributes, property) {
   return caseSensitiveTransform(attributes, property.toLowerCase());
 }
-__name(caseInsensitiveTransform, "caseInsensitiveTransform");
 var xmlns = create({
   space: "xmlns",
   attributes: { xmlnsxlink: "xmlns:xlink" },
   transform: caseInsensitiveTransform,
   properties: { xmlns: null, xmlnsXLink: null }
-});
-var aria = create({
+}), aria = create({
   transform(_, prop) {
     return prop === "role" ? prop : "aria-" + prop.slice(4).toLowerCase();
   },
@@ -471,8 +324,7 @@ var aria = create({
     ariaValueText: null,
     role: null
   }
-});
-var html = create({
+}), html = create({
   space: "html",
   attributes: {
     acceptcharset: "accept-charset",
@@ -831,8 +683,7 @@ var html = create({
     security: null,
     unselectable: null
   }
-});
-var svg = create({
+}), svg = create({
   space: "svg",
   attributes: {
     accentHeight: "accent-height",
@@ -1391,44 +1242,32 @@ var svg = create({
     z: null,
     zoomAndPan: null
   }
-});
-var valid = /^data[-\w.:]+$/i;
-var dash = /-[a-z]/g;
-var cap = /[A-Z]/g;
+}), valid = /^data[-\w.:]+$/i, dash = /-[a-z]/g, cap = /[A-Z]/g;
 function find(schema, value) {
-  const normal = normalize(value);
-  let prop = value;
-  let Type = Info;
-  if (normal in schema.normal) {
+  let normal = normalize(value), prop = value, Type = Info;
+  if (normal in schema.normal)
     return schema.property[schema.normal[normal]];
-  }
   if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value)) {
     if (value.charAt(4) === "-") {
-      const rest = value.slice(5).replace(dash, camelcase);
+      let rest = value.slice(5).replace(dash, camelcase);
       prop = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
     } else {
-      const rest = value.slice(4);
+      let rest = value.slice(4);
       if (!dash.test(rest)) {
         let dashes = rest.replace(cap, kebab);
-        if (dashes.charAt(0) !== "-") {
-          dashes = "-" + dashes;
-        }
-        value = "data" + dashes;
+        dashes.charAt(0) !== "-" && (dashes = "-" + dashes), value = "data" + dashes;
       }
     }
     Type = DefinedInfo;
   }
   return new Type(prop, value);
 }
-__name(find, "find");
 function kebab($0) {
   return "-" + $0.toLowerCase();
 }
-__name(kebab, "kebab");
 function camelcase($0) {
   return $0.charAt(1).toUpperCase();
 }
-__name(camelcase, "camelcase");
 var hastToReact = {
   classId: "classID",
   dataType: "datatype",
@@ -1447,222 +1286,151 @@ var hastToReact = {
   xLinkTitle: "xlinkTitle",
   xLinkType: "xlinkType",
   xmlnsXLink: "xmlnsXlink"
-};
-var html2 = merge([xml, xlink, xmlns, aria, html], "html");
-var svg2 = merge([xml, xlink, xmlns, aria, svg], "svg");
-var pointEnd = point("end");
-var pointStart = point("start");
+}, html2 = merge([xml, xlink, xmlns, aria, html], "html"), svg2 = merge([xml, xlink, xmlns, aria, svg], "svg"), pointEnd = point("end"), pointStart = point("start");
 function point(type) {
   return point2;
   function point2(node) {
-    const point3 = node && node.position && node.position[type] || {};
-    if (typeof point3.line === "number" && point3.line > 0 && typeof point3.column === "number" && point3.column > 0) {
+    let point3 = node && node.position && node.position[type] || {};
+    if (typeof point3.line == "number" && point3.line > 0 && typeof point3.column == "number" && point3.column > 0)
       return {
         line: point3.line,
         column: point3.column,
-        offset: typeof point3.offset === "number" && point3.offset > -1 ? point3.offset : void 0
+        offset: typeof point3.offset == "number" && point3.offset > -1 ? point3.offset : void 0
       };
-    }
   }
-  __name(point2, "point2");
 }
-__name(point, "point");
 function position(node) {
-  const start2 = pointStart(node);
-  const end = pointEnd(node);
-  if (start2 && end) {
+  let start2 = pointStart(node), end = pointEnd(node);
+  if (start2 && end)
     return { start: start2, end };
-  }
 }
-__name(position, "position");
 var own2 = {}.hasOwnProperty;
 function zwitch(key, options) {
-  const settings = options || {};
+  let settings = options || {};
   function one(value, ...parameters) {
-    let fn = one.invalid;
-    const handlers2 = one.handlers;
+    let fn = one.invalid, handlers2 = one.handlers;
     if (value && own2.call(value, key)) {
-      const id = String(value[key]);
+      let id = String(value[key]);
       fn = own2.call(handlers2, id) ? handlers2[id] : one.unknown;
     }
-    if (fn) {
+    if (fn)
       return fn.call(this, value, ...parameters);
-    }
   }
-  __name(one, "one");
-  one.handlers = settings.handlers || {};
-  one.invalid = settings.invalid;
-  one.unknown = settings.unknown;
-  return one;
+  return one.handlers = settings.handlers || {}, one.invalid = settings.invalid, one.unknown = settings.unknown, one;
 }
-__name(zwitch, "zwitch");
 function comment(node, state) {
-  const result = { type: "Block", value: node.value };
-  state.inherit(node, result);
-  state.comments.push(result);
-  const expression = {
+  let result = { type: "Block", value: node.value };
+  state.inherit(node, result), state.comments.push(result);
+  let expression = {
     type: "JSXEmptyExpression",
     // @ts-expect-error: `comments` is custom.
-    comments: [Object.assign({}, result, { leading: false, trailing: true })]
+    comments: [Object.assign({}, result, { leading: !1, trailing: !0 })]
   };
   state.patch(node, expression);
-  const container = { type: "JSXExpressionContainer", expression };
-  state.patch(node, container);
-  return container;
+  let container = { type: "JSXExpressionContainer", expression };
+  return state.patch(node, container), container;
 }
-__name(comment, "comment");
 function stringify(values, options) {
-  const settings = options || {};
-  const input = values[values.length - 1] === "" ? [...values, ""] : values;
-  return input.join(
-    (settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
+  let settings = options || {};
+  return (values[values.length - 1] === "" ? [...values, ""] : values).join(
+    (settings.padRight ? " " : "") + "," + (settings.padLeft === !1 ? "" : " ")
   ).trim();
 }
-__name(stringify, "stringify");
-var startRe = /[$_\p{ID_Start}]/u;
-var contRe = /[$_\u{200C}\u{200D}\p{ID_Continue}]/u;
-var contReJsx = /[-$_\u{200C}\u{200D}\p{ID_Continue}]/u;
-var nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
-var nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
-var emptyOptions = {};
+var startRe = /[$_\p{ID_Start}]/u, contRe = /[$_\u{200C}\u{200D}\p{ID_Continue}]/u, contReJsx = /[-$_\u{200C}\u{200D}\p{ID_Continue}]/u, nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u, nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u, emptyOptions = {};
 function start(code) {
-  return code ? startRe.test(String.fromCodePoint(code)) : false;
+  return code ? startRe.test(String.fromCodePoint(code)) : !1;
 }
-__name(start, "start");
 function cont(code, options) {
-  const settings = options || emptyOptions;
-  const re2 = settings.jsx ? contReJsx : contRe;
-  return code ? re2.test(String.fromCodePoint(code)) : false;
+  let re2 = (options || emptyOptions).jsx ? contReJsx : contRe;
+  return code ? re2.test(String.fromCodePoint(code)) : !1;
 }
-__name(cont, "cont");
 function name(name2, options) {
-  const settings = options || emptyOptions;
-  const re2 = settings.jsx ? nameReJsx : nameRe;
-  return re2.test(name2);
+  return ((options || emptyOptions).jsx ? nameReJsx : nameRe).test(name2);
 }
-__name(name, "name");
 function stringify2(values) {
   return values.join(" ").trim();
 }
-__name(stringify2, "stringify2");
-var import_index = __toESM(require_style_to_object(), 1);
-var style_to_object_default = import_index.default;
-var own3 = {}.hasOwnProperty;
-var cap2 = /[A-Z]/g;
-var dashSomething = /-([a-z])/g;
-var tableCellElement = /* @__PURE__ */ new Set(["td", "th"]);
+var import_index = __toESM(require_style_to_object(), 1), style_to_object_default = import_index.default, own3 = {}.hasOwnProperty, cap2 = /[A-Z]/g, dashSomething = /-([a-z])/g, tableCellElement = /* @__PURE__ */ new Set(["td", "th"]);
 function element(node, state) {
-  const parentSchema = state.schema;
-  let schema = parentSchema;
-  const props = node.properties || {};
-  if (parentSchema.space === "html" && node.tagName.toLowerCase() === "svg") {
-    schema = svg2;
-    state.schema = schema;
-  }
-  const children = state.all(node);
-  const attributes = [];
-  let prop;
-  let alignValue;
-  let styleProperties;
-  for (prop in props) {
+  let parentSchema = state.schema, schema = parentSchema, props = node.properties || {};
+  parentSchema.space === "html" && node.tagName.toLowerCase() === "svg" && (schema = svg2, state.schema = schema);
+  let children = state.all(node), attributes = [], prop, alignValue, styleProperties;
+  for (prop in props)
     if (own3.call(props, prop)) {
-      let value = props[prop];
-      const info = find(schema, prop);
-      let attributeValue;
-      if (value === null || value === void 0 || value === false || typeof value === "number" && Number.isNaN(value) || !value && info.boolean) {
+      let value = props[prop], info = find(schema, prop), attributeValue;
+      if (value == null || value === !1 || typeof value == "number" && Number.isNaN(value) || !value && info.boolean)
         continue;
-      }
-      prop = state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute;
-      if (Array.isArray(value)) {
-        value = info.commaSeparated ? stringify(value) : stringify2(value);
-      }
-      if (prop === "style") {
-        let styleObject = typeof value === "object" ? value : parseStyle(String(value), node.tagName);
-        if (state.stylePropertyNameCase === "css") {
-          styleObject = transformStylesToCssCasing(styleObject);
-        }
-        const cssProperties = [];
-        let cssProp;
-        for (cssProp in styleObject) {
-          if (own3.call(styleObject, cssProp)) {
-            cssProperties.push({
-              type: "Property",
-              method: false,
-              shorthand: false,
-              computed: false,
-              key: name(cssProp) ? { type: "Identifier", name: cssProp } : { type: "Literal", value: cssProp },
-              value: { type: "Literal", value: String(styleObject[cssProp]) },
-              kind: "init"
-            });
-          }
-        }
-        styleProperties = cssProperties;
-        attributeValue = {
+      if (prop = state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute, Array.isArray(value) && (value = info.commaSeparated ? stringify(value) : stringify2(value)), prop === "style") {
+        let styleObject = typeof value == "object" ? value : parseStyle(String(value), node.tagName);
+        state.stylePropertyNameCase === "css" && (styleObject = transformStylesToCssCasing(styleObject));
+        let cssProperties = [], cssProp;
+        for (cssProp in styleObject)
+          own3.call(styleObject, cssProp) && cssProperties.push({
+            type: "Property",
+            method: !1,
+            shorthand: !1,
+            computed: !1,
+            key: name(cssProp) ? { type: "Identifier", name: cssProp } : { type: "Literal", value: cssProp },
+            value: { type: "Literal", value: String(styleObject[cssProp]) },
+            kind: "init"
+          });
+        styleProperties = cssProperties, attributeValue = {
           type: "JSXExpressionContainer",
           expression: { type: "ObjectExpression", properties: cssProperties }
         };
-      } else if (value === true) {
+      } else if (value === !0)
         attributeValue = null;
-      } else if (state.tableCellAlignToStyle && tableCellElement.has(node.tagName) && prop === "align") {
+      else if (state.tableCellAlignToStyle && tableCellElement.has(node.tagName) && prop === "align") {
         alignValue = String(value);
         continue;
-      } else {
+      } else
         attributeValue = { type: "Literal", value: String(value) };
-      }
-      if (name(prop, { jsx: true })) {
-        attributes.push({
-          type: "JSXAttribute",
-          name: { type: "JSXIdentifier", name: prop },
-          value: attributeValue
-        });
-      } else {
-        attributes.push({
-          type: "JSXSpreadAttribute",
-          argument: {
-            type: "ObjectExpression",
-            properties: [
-              {
-                type: "Property",
-                method: false,
-                shorthand: false,
-                computed: false,
-                key: { type: "Literal", value: String(prop) },
-                // @ts-expect-error No need to worry about `style` (which has a
-                // `JSXExpressionContainer` value) because that’s a valid identifier.
-                value: attributeValue || { type: "Literal", value: true },
-                kind: "init"
-              }
-            ]
-          }
-        });
-      }
-    }
-  }
-  if (alignValue !== void 0) {
-    if (!styleProperties) {
-      styleProperties = [];
-      attributes.push({
+      name(prop, { jsx: !0 }) ? attributes.push({
         type: "JSXAttribute",
-        name: { type: "JSXIdentifier", name: "style" },
-        value: {
-          type: "JSXExpressionContainer",
-          expression: { type: "ObjectExpression", properties: styleProperties }
+        name: { type: "JSXIdentifier", name: prop },
+        value: attributeValue
+      }) : attributes.push({
+        type: "JSXSpreadAttribute",
+        argument: {
+          type: "ObjectExpression",
+          properties: [
+            {
+              type: "Property",
+              method: !1,
+              shorthand: !1,
+              computed: !1,
+              key: { type: "Literal", value: String(prop) },
+              // @ts-expect-error No need to worry about `style` (which has a
+              // `JSXExpressionContainer` value) because that’s a valid identifier.
+              value: attributeValue || { type: "Literal", value: !0 },
+              kind: "init"
+            }
+          ]
         }
       });
     }
-    const cssProp = state.stylePropertyNameCase === "css" ? transformStyleToCssCasing("textAlign") : "textAlign";
+  if (alignValue !== void 0) {
+    styleProperties || (styleProperties = [], attributes.push({
+      type: "JSXAttribute",
+      name: { type: "JSXIdentifier", name: "style" },
+      value: {
+        type: "JSXExpressionContainer",
+        expression: { type: "ObjectExpression", properties: styleProperties }
+      }
+    }));
+    let cssProp = state.stylePropertyNameCase === "css" ? transformStyleToCssCasing("textAlign") : "textAlign";
     styleProperties.push({
       type: "Property",
-      method: false,
-      shorthand: false,
-      computed: false,
+      method: !1,
+      shorthand: !1,
+      computed: !1,
       key: name(cssProp) ? { type: "Identifier", name: cssProp } : { type: "Literal", value: cssProp },
       value: { type: "Literal", value: alignValue },
       kind: "init"
     });
   }
   state.schema = parentSchema;
-  const result = {
+  let result = {
     type: "JSXElement",
     openingElement: {
       type: "JSXOpeningElement",
@@ -1676,214 +1444,125 @@ function element(node, state) {
     } : null,
     children
   };
-  state.inherit(node, result);
-  return result;
+  return state.inherit(node, result), result;
 }
-__name(element, "element");
 function parseStyle(value, tagName) {
-  const result = {};
+  let result = {};
   try {
     style_to_object_default(value, iterator);
   } catch (error) {
-    const cause = (
+    let cause = (
       /** @type {Error} */
       error
     );
-    const exception = new Error(
+    throw new Error(
       "Could not parse `style` attribute on `" + tagName + "`",
       { cause }
     );
-    throw exception;
   }
   return result;
   function iterator(name2, value2) {
     let key = name2;
-    if (key.slice(0, 2) !== "--") {
-      if (key.slice(0, 4) === "-ms-")
-        key = "ms-" + key.slice(4);
-      key = key.replace(dashSomething, toCamel);
-    }
-    result[key] = value2;
+    key.slice(0, 2) !== "--" && (key.slice(0, 4) === "-ms-" && (key = "ms-" + key.slice(4)), key = key.replace(dashSomething, toCamel)), result[key] = value2;
   }
-  __name(iterator, "iterator");
 }
-__name(parseStyle, "parseStyle");
 function transformStylesToCssCasing(domCasing) {
-  const cssCasing = {};
-  let from;
-  for (from in domCasing) {
-    if (own3.call(domCasing, from)) {
-      cssCasing[transformStyleToCssCasing(from)] = domCasing[from];
-    }
-  }
+  let cssCasing = {}, from;
+  for (from in domCasing)
+    own3.call(domCasing, from) && (cssCasing[transformStyleToCssCasing(from)] = domCasing[from]);
   return cssCasing;
 }
-__name(transformStylesToCssCasing, "transformStylesToCssCasing");
 function transformStyleToCssCasing(from) {
   let to = from.replace(cap2, toDash);
-  if (to.slice(0, 3) === "ms-")
-    to = "-" + to;
-  return to;
+  return to.slice(0, 3) === "ms-" && (to = "-" + to), to;
 }
-__name(transformStyleToCssCasing, "transformStyleToCssCasing");
 function toCamel(_, $1) {
   return $1.toUpperCase();
 }
-__name(toCamel, "toCamel");
 function toDash($0) {
   return "-" + $0.toLowerCase();
 }
-__name(toDash, "toDash");
-var own4 = {}.hasOwnProperty;
-var emptyComments = [];
+var own4 = {}.hasOwnProperty, emptyComments = [];
 function attachComments(tree, comments) {
-  const list = comments ? [...comments].sort(compare) : emptyComments;
-  if (list.length > 0)
-    walk(tree, { comments: list, index: 0 });
+  let list = comments ? [...comments].sort(compare) : emptyComments;
+  list.length > 0 && walk(tree, { comments: list, index: 0 });
 }
-__name(attachComments, "attachComments");
 function walk(node, state) {
-  if (state.index === state.comments.length) {
+  if (state.index === state.comments.length)
     return;
-  }
-  const children = [];
-  const comments = [];
-  let key;
-  for (key in node) {
+  let children = [], comments = [], key;
+  for (key in node)
     if (own4.call(node, key)) {
-      const value = node[key];
-      if (value && typeof value === "object" && key !== "comments") {
+      let value = node[key];
+      if (value && typeof value == "object" && key !== "comments")
         if (Array.isArray(value)) {
           let index2 = -1;
-          while (++index2 < value.length) {
-            if (value[index2] && typeof value[index2].type === "string") {
-              children.push(value[index2]);
-            }
-          }
-        } else if (typeof value.type === "string") {
-          children.push(value);
-        }
-      }
+          for (; ++index2 < value.length; )
+            value[index2] && typeof value[index2].type == "string" && children.push(value[index2]);
+        } else typeof value.type == "string" && children.push(value);
     }
-  }
-  children.sort(compare);
-  comments.push(...slice(state, node, false, { leading: true, trailing: false }));
+  children.sort(compare), comments.push(...slice(state, node, !1, { leading: !0, trailing: !1 }));
   let index = -1;
-  while (++index < children.length) {
+  for (; ++index < children.length; )
     walk(children[index], state);
-  }
   comments.push(
-    ...slice(state, node, true, {
-      leading: false,
+    ...slice(state, node, !0, {
+      leading: !1,
       trailing: children.length > 0
     })
-  );
-  if (comments.length > 0) {
-    node.comments = comments;
-  }
+  ), comments.length > 0 && (node.comments = comments);
 }
-__name(walk, "walk");
 function slice(state, node, compareEnd, fields) {
-  const result = [];
-  while (state.comments[state.index] && compare(state.comments[state.index], node, compareEnd) < 1) {
+  let result = [];
+  for (; state.comments[state.index] && compare(state.comments[state.index], node, compareEnd) < 1; )
     result.push(Object.assign({}, state.comments[state.index++], fields));
-  }
   return result;
 }
-__name(slice, "slice");
 function compare(left, right, compareEnd) {
-  const field = compareEnd ? "end" : "start";
-  if (left.range && right.range) {
-    return left.range[0] - right.range[compareEnd ? 1 : 0];
-  }
-  if (left.loc && left.loc.start && right.loc && right.loc[field]) {
-    return left.loc.start.line - right.loc[field].line || left.loc.start.column - right.loc[field].column;
-  }
-  if ("start" in left && field in right) {
-    return left.start - right[field];
-  }
-  return Number.NaN;
+  let field = compareEnd ? "end" : "start";
+  return left.range && right.range ? left.range[0] - right.range[compareEnd ? 1 : 0] : left.loc && left.loc.start && right.loc && right.loc[field] ? left.loc.start.line - right.loc[field].line || left.loc.start.column - right.loc[field].column : "start" in left && field in right ? left.start - right[field] : Number.NaN;
 }
-__name(compare, "compare");
 function mdxExpression(node, state) {
-  const estree = node.data && node.data.estree;
-  const comments = estree && estree.comments || [];
-  let expression;
-  if (estree) {
-    state.comments.push(...comments);
-    attachComments(estree, estree.comments);
-    expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0;
-  }
-  if (!expression) {
-    expression = { type: "JSXEmptyExpression" };
-    state.patch(node, expression);
-  }
-  const result = { type: "JSXExpressionContainer", expression };
-  state.inherit(node, result);
-  return result;
+  let estree = node.data && node.data.estree, comments = estree && estree.comments || [], expression;
+  estree && (state.comments.push(...comments), attachComments(estree, estree.comments), expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0), expression || (expression = { type: "JSXEmptyExpression" }, state.patch(node, expression));
+  let result = { type: "JSXExpressionContainer", expression };
+  return state.inherit(node, result), result;
 }
-__name(mdxExpression, "mdxExpression");
 function mdxJsxElement(node, state) {
-  const parentSchema = state.schema;
-  let schema = parentSchema;
-  const attrs = node.attributes || [];
-  let index = -1;
-  if (node.name && parentSchema.space === "html" && node.name.toLowerCase() === "svg") {
-    schema = svg2;
-    state.schema = schema;
-  }
-  const children = state.all(node);
-  const attributes = [];
-  while (++index < attrs.length) {
-    const attr = attrs[index];
-    const value = attr.value;
-    let attributeValue;
+  let parentSchema = state.schema, schema = parentSchema, attrs = node.attributes || [], index = -1;
+  node.name && parentSchema.space === "html" && node.name.toLowerCase() === "svg" && (schema = svg2, state.schema = schema);
+  let children = state.all(node), attributes = [];
+  for (; ++index < attrs.length; ) {
+    let attr = attrs[index], value = attr.value, attributeValue;
     if (attr.type === "mdxJsxAttribute") {
-      if (value === null || value === void 0) {
+      if (value == null)
         attributeValue = null;
-      } else if (typeof value === "object") {
-        const estree = value.data && value.data.estree;
-        const comments = estree && estree.comments || [];
-        let expression;
-        if (estree) {
-          state.comments.push(...comments);
-          attachComments(estree, estree.comments);
-          expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0;
-        }
-        attributeValue = {
+      else if (typeof value == "object") {
+        let estree = value.data && value.data.estree, comments = estree && estree.comments || [], expression;
+        estree && (state.comments.push(...comments), attachComments(estree, estree.comments), expression = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression || void 0), attributeValue = {
           type: "JSXExpressionContainer",
           expression: expression || { type: "JSXEmptyExpression" }
-        };
-        state.inherit(value, attributeValue);
-      } else {
+        }, state.inherit(value, attributeValue);
+      } else
         attributeValue = { type: "Literal", value: String(value) };
-      }
-      const attribute = {
+      let attribute = {
         type: "JSXAttribute",
         name: state.createJsxAttributeName(attr.name),
         value: attributeValue
       };
-      state.inherit(attr, attribute);
-      attributes.push(attribute);
+      state.inherit(attr, attribute), attributes.push(attribute);
     } else {
-      const estree = attr.data && attr.data.estree;
-      const comments = estree && estree.comments || [];
-      let argumentValue;
-      if (estree) {
-        state.comments.push(...comments);
-        attachComments(estree, estree.comments);
-        argumentValue = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression && estree.body[0].expression.type === "ObjectExpression" && estree.body[0].expression.properties && estree.body[0].expression.properties[0] && estree.body[0].expression.properties[0].type === "SpreadElement" && estree.body[0].expression.properties[0].argument || void 0;
-      }
-      const attribute = {
+      let estree = attr.data && attr.data.estree, comments = estree && estree.comments || [], argumentValue;
+      estree && (state.comments.push(...comments), attachComments(estree, estree.comments), argumentValue = estree.body[0] && estree.body[0].type === "ExpressionStatement" && estree.body[0].expression && estree.body[0].expression.type === "ObjectExpression" && estree.body[0].expression.properties && estree.body[0].expression.properties[0] && estree.body[0].expression.properties[0].type === "SpreadElement" && estree.body[0].expression.properties[0].argument || void 0);
+      let attribute = {
         type: "JSXSpreadAttribute",
         argument: argumentValue || { type: "ObjectExpression", properties: [] }
       };
-      state.inherit(attr, attribute);
-      attributes.push(attribute);
+      state.inherit(attr, attribute), attributes.push(attribute);
     }
   }
   state.schema = parentSchema;
-  const result = node.name ? {
+  let result = node.name ? {
     type: "JSXElement",
     openingElement: {
       type: "JSXOpeningElement",
@@ -1902,67 +1581,42 @@ function mdxJsxElement(node, state) {
     closingFragment: { type: "JSXClosingFragment" },
     children
   };
-  state.inherit(node, result);
-  return result;
+  return state.inherit(node, result), result;
 }
-__name(mdxJsxElement, "mdxJsxElement");
 function mdxjsEsm(node, state) {
-  const estree = node.data && node.data.estree;
-  const comments = estree && estree.comments || [];
-  if (estree) {
-    state.comments.push(...comments);
-    attachComments(estree, comments);
-    state.esm.push(...estree.body);
-  }
+  let estree = node.data && node.data.estree, comments = estree && estree.comments || [];
+  estree && (state.comments.push(...comments), attachComments(estree, comments), state.esm.push(...estree.body));
 }
-__name(mdxjsEsm, "mdxjsEsm");
 var re = /[ \t\n\f\r]/g;
 function whitespace(thing) {
-  return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
+  return typeof thing == "object" ? thing.type === "text" ? empty(thing.value) : !1 : empty(thing);
 }
-__name(whitespace, "whitespace");
 function empty(value) {
   return value.replace(re, "") === "";
 }
-__name(empty, "empty");
 function root(node, state) {
-  const children = state.all(node);
-  const cleanChildren = [];
-  let index = -1;
-  let queue;
-  while (++index < children.length) {
-    const child = children[index];
-    if (child.type === "JSXExpressionContainer" && child.expression.type === "Literal" && whitespace(String(child.expression.value))) {
-      if (queue)
-        queue.push(child);
-    } else {
-      if (queue)
-        cleanChildren.push(...queue);
-      cleanChildren.push(child);
-      queue = [];
-    }
+  let children = state.all(node), cleanChildren = [], index = -1, queue;
+  for (; ++index < children.length; ) {
+    let child = children[index];
+    child.type === "JSXExpressionContainer" && child.expression.type === "Literal" && whitespace(String(child.expression.value)) ? queue && queue.push(child) : (queue && cleanChildren.push(...queue), cleanChildren.push(child), queue = []);
   }
-  const result = {
+  let result = {
     type: "JSXFragment",
     openingFragment: { type: "JSXOpeningFragment" },
     closingFragment: { type: "JSXClosingFragment" },
     children: cleanChildren
   };
-  state.inherit(node, result);
-  return result;
+  return state.inherit(node, result), result;
 }
-__name(root, "root");
 function text(node, state) {
-  const value = String(node.value || "");
+  let value = String(node.value || "");
   if (value) {
-    const result = { type: "Literal", value };
+    let result = { type: "Literal", value };
     state.inherit(node, result);
-    const container = { type: "JSXExpressionContainer", expression: result };
-    state.patch(node, container);
-    return container;
+    let container = { type: "JSXExpressionContainer", expression: result };
+    return state.patch(node, container), container;
   }
 }
-__name(text, "text");
 var handlers = {
   comment,
   doctype: ignore,
@@ -1977,11 +1631,9 @@ var handlers = {
 };
 function ignore() {
 }
-__name(ignore, "ignore");
-var own5 = {}.hasOwnProperty;
-var tableElements = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
+var own5 = {}.hasOwnProperty, tableElements = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
 function createState(options) {
-  const one = zwitch("type", {
+  let one = zwitch("type", {
     invalid,
     unknown,
     handlers: { ...handlers, ...options.handlers }
@@ -1991,7 +1643,7 @@ function createState(options) {
     elementAttributeNameCase: options.elementAttributeNameCase || "react",
     schema: options.space === "svg" ? svg2 : html2,
     stylePropertyNameCase: options.stylePropertyNameCase || "dom",
-    tableCellAlignToStyle: options.tableCellAlignToStyle !== false,
+    tableCellAlignToStyle: options.tableCellAlignToStyle !== !1,
     // Results.
     comments: [],
     esm: [],
@@ -2006,103 +1658,66 @@ function createState(options) {
   function handle(node) {
     return one(node, this);
   }
-  __name(handle, "handle");
 }
-__name(createState, "createState");
 function invalid(value) {
   throw new Error("Cannot handle value `" + value + "`, expected node");
 }
-__name(invalid, "invalid");
 function unknown(node) {
-  ok(node && typeof node === "object");
-  ok("type" in node);
-  throw new Error("Cannot handle unknown node `" + node.type + "`");
+  throw "type" in node, new Error("Cannot handle unknown node `" + node.type + "`");
 }
-__name(unknown, "unknown");
 function all(parent) {
-  const children = parent.children || [];
-  let index = -1;
-  const results = [];
-  const ignoreLineBreak = this.schema.space === "html" && parent.type === "element" && tableElements.has(parent.tagName.toLowerCase());
-  while (++index < children.length) {
-    const child = children[index];
-    if (ignoreLineBreak && child.type === "text" && child.value === "\n") {
+  let children = parent.children || [], index = -1, results = [], ignoreLineBreak = this.schema.space === "html" && parent.type === "element" && tableElements.has(parent.tagName.toLowerCase());
+  for (; ++index < children.length; ) {
+    let child = children[index];
+    if (ignoreLineBreak && child.type === "text" && child.value === `
+`)
       continue;
-    }
-    const result = this.handle(child);
-    if (Array.isArray(result)) {
-      results.push(...result);
-    } else if (result) {
-      results.push(result);
-    }
+    let result = this.handle(child);
+    Array.isArray(result) ? results.push(...result) : result && results.push(result);
   }
   return results;
 }
-__name(all, "all");
 function inherit(from, to) {
-  const left = (
+  let left = (
     /** @type {Record<string, unknown> | undefined} */
     from.data
-  );
-  let right;
-  let key;
-  patch(from, to);
-  if (left) {
-    for (key in left) {
-      if (own5.call(left, key) && key !== "estree") {
-        if (!right)
-          right = {};
-        right[key] = left[key];
-      }
-    }
-    if (right) {
-      to.data = right;
-    }
+  ), right, key;
+  if (patch(from, to), left) {
+    for (key in left)
+      own5.call(left, key) && key !== "estree" && (right || (right = {}), right[key] = left[key]);
+    right && (to.data = right);
   }
 }
-__name(inherit, "inherit");
 function patch(from, to) {
-  const p = position(from);
-  if (p && p.start.offset !== void 0 && p.end.offset !== void 0) {
-    to.start = p.start.offset;
-    to.end = p.end.offset;
-    to.loc = {
-      start: { line: p.start.line, column: p.start.column - 1 },
-      end: { line: p.end.line, column: p.end.column - 1 }
-    };
-    to.range = [p.start.offset, p.end.offset];
-  }
+  let p = position(from);
+  p && p.start.offset !== void 0 && p.end.offset !== void 0 && (to.start = p.start.offset, to.end = p.end.offset, to.loc = {
+    start: { line: p.start.line, column: p.start.column - 1 },
+    end: { line: p.end.line, column: p.end.column - 1 }
+  }, to.range = [p.start.offset, p.end.offset]);
 }
-__name(patch, "patch");
 function createJsxAttributeName(name2) {
-  const node = createJsxNameFromString(name2);
-  if (node.type === "JSXMemberExpression") {
+  let node = createJsxNameFromString(name2);
+  if (node.type === "JSXMemberExpression")
     throw new Error("Member expressions in attribute names are not supported");
-  }
   return node;
 }
-__name(createJsxAttributeName, "createJsxAttributeName");
 function createJsxElementName(name2) {
   return createJsxNameFromString(name2);
 }
-__name(createJsxElementName, "createJsxElementName");
 function createJsxNameFromString(name2) {
   if (name2.includes(".")) {
-    const names = name2.split(".");
-    let part = names.shift();
-    ok(part, "Expected `part` to be defined");
+    let names = name2.split("."), part = names.shift();
     let node = { type: "JSXIdentifier", name: part };
-    while (part = names.shift()) {
+    for (; part = names.shift(); )
       node = {
         type: "JSXMemberExpression",
         object: node,
         property: { type: "JSXIdentifier", name: part }
       };
-    }
     return node;
   }
   if (name2.includes(":")) {
-    const parts = name2.split(":");
+    let parts = name2.split(":");
     return {
       type: "JSXNamespacedName",
       namespace: { type: "JSXIdentifier", name: parts[0] },
@@ -2111,43 +1726,32 @@ function createJsxNameFromString(name2) {
   }
   return { type: "JSXIdentifier", name: name2 };
 }
-__name(createJsxNameFromString, "createJsxNameFromString");
 function toEstree(tree, options) {
-  const state = createState(options || {});
-  let result = state.handle(tree);
-  const body = state.esm;
+  let state = createState(options || {}), result = state.handle(tree), body = state.esm;
   if (result) {
-    if (result.type !== "JSXFragment" && result.type !== "JSXElement") {
-      result = {
-        type: "JSXFragment",
-        openingFragment: { type: "JSXOpeningFragment" },
-        closingFragment: { type: "JSXClosingFragment" },
-        children: [result]
-      };
-      state.patch(tree, result);
-    }
-    const statement = { type: "ExpressionStatement", expression: result };
-    state.patch(tree, statement);
-    body.push(statement);
+    result.type !== "JSXFragment" && result.type !== "JSXElement" && (result = {
+      type: "JSXFragment",
+      openingFragment: { type: "JSXOpeningFragment" },
+      closingFragment: { type: "JSXClosingFragment" },
+      children: [result]
+    }, state.patch(tree, result));
+    let statement = { type: "ExpressionStatement", expression: result };
+    state.patch(tree, statement), body.push(statement);
   }
-  const program = {
+  let program = {
     type: "Program",
     body,
     sourceType: "module",
     comments: state.comments
   };
-  state.patch(tree, program);
-  return program;
+  return state.patch(tree, program), program;
 }
-__name(toEstree, "toEstree");
 
 export {
   __require2 as __require,
   __commonJS,
   __export,
   __toESM,
-  ok,
-  unreachable,
   pointEnd,
   pointStart,
   position,