@jobber/components 7.1.2-MIKElock--7916eb4.2 → 7.2.0

package/dist/Markdown-es.js

@@ -3,7 +3,7 @@ import { T as Text } from './Text-es.js';
 import { E as Emphasis } from './Emphasis-es.js';
 import { H as Heading } from './Heading-es.js';
 import { C as Content } from './Content-es.js';
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Fragment, jsx, jsxs } from 'react/jsx-runtime';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers-es.js';
 
 function ok$1() {}
@@ -110,107 +110,93 @@ function empty$1(value) {
 }
 
 /**
- * @import {Schema as SchemaType, Space} from 'property-information'
+ * @typedef {import('./info.js').Info} Info
+ * @typedef {Record<string, Info>} Properties
+ * @typedef {Record<string, string>} Normal
  */
 
-/** @type {SchemaType} */
 class Schema {
   /**
-   * @param {SchemaType['property']} property
-   *   Property.
-   * @param {SchemaType['normal']} normal
-   *   Normal.
-   * @param {Space | undefined} [space]
-   *   Space.
-   * @returns
-   *   Schema.
+   * @constructor
+   * @param {Properties} property
+   * @param {Normal} normal
+   * @param {string} [space]
    */
   constructor(property, normal, space) {
-    this.normal = normal;
     this.property = property;
-
+    this.normal = normal;
     if (space) {
       this.space = space;
     }
   }
 }
 
-Schema.prototype.normal = {};
+/** @type {Properties} */
 Schema.prototype.property = {};
-Schema.prototype.space = undefined;
+/** @type {Normal} */
+Schema.prototype.normal = {};
+/** @type {string|null} */
+Schema.prototype.space = null;
 
 /**
- * @import {Info, Space} from 'property-information'
+ * @typedef {import('./schema.js').Properties} Properties
+ * @typedef {import('./schema.js').Normal} Normal
  */
 
 
 /**
- * @param {ReadonlyArray<Schema>} definitions
- *   Definitions.
- * @param {Space | undefined} [space]
- *   Space.
+ * @param {Schema[]} definitions
+ * @param {string} [space]
  * @returns {Schema}
- *   Schema.
  */
 function merge(definitions, space) {
-  /** @type {Record<string, Info>} */
+  /** @type {Properties} */
   const property = {};
-  /** @type {Record<string, string>} */
+  /** @type {Normal} */
   const normal = {};
+  let index = -1;
 
-  for (const definition of definitions) {
-    Object.assign(property, definition.property);
-    Object.assign(normal, definition.normal);
+  while (++index < definitions.length) {
+    Object.assign(property, definitions[index].property);
+    Object.assign(normal, definitions[index].normal);
   }
 
   return new Schema(property, normal, space)
 }
 
 /**
- * Get the cleaned case insensitive form of an attribute or property.
- *
  * @param {string} value
- *   An attribute-like or property-like name.
  * @returns {string}
- *   Value that can be used to look up the properly cased property on a
- *   `Schema`.
  */
 function normalize$1(value) {
   return value.toLowerCase()
 }
 
-/**
- * @import {Info as InfoType} from 'property-information'
- */
-
-/** @type {InfoType} */
 class Info {
   /**
+   * @constructor
    * @param {string} property
-   *   Property.
    * @param {string} attribute
-   *   Attribute.
-   * @returns
-   *   Info.
    */
   constructor(property, attribute) {
-    this.attribute = attribute;
+    /** @type {string} */
     this.property = property;
+    /** @type {string} */
+    this.attribute = attribute;
   }
 }
 
-Info.prototype.attribute = '';
-Info.prototype.booleanish = false;
+/** @type {string|null} */
+Info.prototype.space = null;
 Info.prototype.boolean = false;
-Info.prototype.commaOrSpaceSeparated = false;
-Info.prototype.commaSeparated = false;
-Info.prototype.defined = false;
-Info.prototype.mustUseProperty = false;
-Info.prototype.number = false;
+Info.prototype.booleanish = false;
 Info.prototype.overloadedBoolean = false;
-Info.prototype.property = '';
+Info.prototype.number = false;
+Info.prototype.commaSeparated = false;
 Info.prototype.spaceSeparated = false;
-Info.prototype.space = undefined;
+Info.prototype.commaOrSpaceSeparated = false;
+Info.prototype.mustUseProperty = false;
+Info.prototype.defined = false;
 
 let powers = 0;
 
@@ -237,28 +223,17 @@ var types = /*#__PURE__*/Object.freeze({
   spaceSeparated: spaceSeparated
 });
 
-/**
- * @import {Space} from 'property-information'
- */
-
-
-const checks = /** @type {ReadonlyArray<keyof typeof types>} */ (
-  Object.keys(types)
-);
+/** @type {Array<keyof types>} */
+// @ts-expect-error: hush.
+const checks = Object.keys(types);
 
 class DefinedInfo extends Info {
   /**
    * @constructor
    * @param {string} property
-   *   Property.
    * @param {string} attribute
-   *   Attribute.
-   * @param {number | null | undefined} [mask]
-   *   Mask.
-   * @param {Space | undefined} [space]
-   *   Space.
-   * @returns
-   *   Info.
+   * @param {number|null} [mask]
+   * @param {string} [space]
    */
   constructor(property, attribute, mask, space) {
     let index = -1;
@@ -279,65 +254,126 @@ class DefinedInfo extends Info {
 DefinedInfo.prototype.defined = true;
 
 /**
- * @template {keyof DefinedInfo} Key
- *   Key type.
  * @param {DefinedInfo} values
- *   Info.
- * @param {Key} key
- *   Key.
- * @param {DefinedInfo[Key]} value
- *   Value.
- * @returns {undefined}
- *   Nothing.
+ * @param {string} key
+ * @param {unknown} value
  */
 function mark(values, key, value) {
   if (value) {
+    // @ts-expect-error: assume `value` matches the expected value of `key`.
     values[key] = value;
   }
 }
 
 /**
- * @import {Info, Space} from 'property-information'
+ * @typedef {import('./schema.js').Properties} Properties
+ * @typedef {import('./schema.js').Normal} Normal
+ *
+ * @typedef {Record<string, string>} Attributes
+ *
+ * @typedef {Object} Definition
+ * @property {Record<string, number|null>} properties
+ * @property {(attributes: Attributes, property: string) => string} transform
+ * @property {string} [space]
+ * @property {Attributes} [attributes]
+ * @property {Array<string>} [mustUseProperty]
  */
 
 
+const own$5 = {}.hasOwnProperty;
+
 /**
  * @param {Definition} definition
- *   Definition.
  * @returns {Schema}
- *   Schema.
  */
 function create(definition) {
-  /** @type {Record<string, Info>} */
-  const properties = {};
-  /** @type {Record<string, string>} */
-  const normals = {};
-
-  for (const [property, value] of Object.entries(definition.properties)) {
-    const info = new DefinedInfo(
-      property,
-      definition.transform(definition.attributes || {}, property),
-      value,
-      definition.space
-    );
+  /** @type {Properties} */
+  const property = {};
+  /** @type {Normal} */
+  const normal = {};
+  /** @type {string} */
+  let prop;
 
-    if (
-      definition.mustUseProperty &&
-      definition.mustUseProperty.includes(property)
-    ) {
-      info.mustUseProperty = true;
+  for (prop in definition.properties) {
+    if (own$5.call(definition.properties, prop)) {
+      const value = definition.properties[prop];
+      const 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$1(prop)] = prop;
+      normal[normalize$1(info.attribute)] = prop;
     }
+  }
 
-    properties[property] = info;
+  return new Schema(property, normal, definition.space)
+}
 
-    normals[normalize$1(property)] = property;
-    normals[normalize$1(info.attribute)] = property;
+const xlink = create({
+  space: 'xlink',
+  transform(_, prop) {
+    return 'xlink:' + prop.slice(5).toLowerCase()
+  },
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
   }
+});
+
+const xml = create({
+  space: 'xml',
+  transform(_, prop) {
+    return 'xml:' + prop.slice(3).toLowerCase()
+  },
+  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}
+});
+
+/**
+ * @param {Record<string, string>} attributes
+ * @param {string} attribute
+ * @returns {string}
+ */
+function caseSensitiveTransform(attributes, attribute) {
+  return attribute in attributes ? attributes[attribute] : attribute
+}
 
-  return new Schema(properties, normals, definition.space)
+/**
+ * @param {Record<string, string>} attributes
+ * @param {string} property
+ * @returns {string}
+ */
+function caseInsensitiveTransform(attributes, property) {
+  return caseSensitiveTransform(attributes, property.toLowerCase())
 }
 
+const xmlns = create({
+  space: 'xmlns',
+  attributes: {xmlnsxlink: 'xmlns:xlink'},
+  transform: caseInsensitiveTransform,
+  properties: {xmlns: null, xmlnsXLink: null}
+});
+
 const aria = create({
+  transform(_, prop) {
+    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()
+  },
   properties: {
     ariaActiveDescendant: null,
     ariaAtomic: booleanish,
@@ -388,45 +424,18 @@ const aria = create({
     ariaValueNow: number,
     ariaValueText: null,
     role: null
-  },
-  transform(_, property) {
-    return property === 'role'
-      ? property
-      : 'aria-' + property.slice(4).toLowerCase()
   }
 });
 
-/**
- * @param {Record<string, string>} attributes
- *   Attributes.
- * @param {string} attribute
- *   Attribute.
- * @returns {string}
- *   Transformed attribute.
- */
-function caseSensitiveTransform(attributes, attribute) {
-  return attribute in attributes ? attributes[attribute] : attribute
-}
-
-/**
- * @param {Record<string, string>} attributes
- *   Attributes.
- * @param {string} property
- *   Property.
- * @returns {string}
- *   Transformed property.
- */
-function caseInsensitiveTransform(attributes, property) {
-  return caseSensitiveTransform(attributes, property.toLowerCase())
-}
-
 const html$2 = create({
+  space: 'html',
   attributes: {
     acceptcharset: 'accept-charset',
     classname: 'class',
     htmlfor: 'for',
     httpequiv: 'http-equiv'
   },
+  transform: caseInsensitiveTransform,
   mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],
   properties: {
     // Standard Properties.
@@ -481,7 +490,7 @@ const html$2 = create({
     formTarget: null,
     headers: spaceSeparated,
     height: number,
-    hidden: overloadedBoolean,
+    hidden: boolean,
     high: number,
     href: null,
     hrefLang: null,
@@ -727,12 +736,11 @@ const html$2 = create({
     results: number,
     security: null,
     unselectable: null
-  },
-  space: 'html',
-  transform: caseInsensitiveTransform
+  }
 });
 
 const svg$1 = create({
+  space: 'svg',
   attributes: {
     accentHeight: 'accent-height',
     alignmentBaseline: 'alignment-baseline',
@@ -908,6 +916,7 @@ const svg$1 = create({
     playbackOrder: 'playbackorder',
     timelineBegin: 'timelinebegin'
   },
+  transform: caseSensitiveTransform,
   properties: {
     about: commaOrSpaceSeparated,
     accentHeight: number,
@@ -1285,115 +1294,26 @@ const svg$1 = create({
     yChannelSelector: null,
     z: null,
     zoomAndPan: null
-  },
-  space: 'svg',
-  transform: caseSensitiveTransform
-});
-
-const xlink = create({
-  properties: {
-    xLinkActuate: null,
-    xLinkArcRole: null,
-    xLinkHref: null,
-    xLinkRole: null,
-    xLinkShow: null,
-    xLinkTitle: null,
-    xLinkType: null
-  },
-  space: 'xlink',
-  transform(_, property) {
-    return 'xlink:' + property.slice(5).toLowerCase()
   }
 });
 
-const xmlns = create({
-  attributes: {xmlnsxlink: 'xmlns:xlink'},
-  properties: {xmlnsXLink: null, xmlns: null},
-  space: 'xmlns',
-  transform: caseInsensitiveTransform
-});
-
-const xml = create({
-  properties: {xmlBase: null, xmlLang: null, xmlSpace: null},
-  space: 'xml',
-  transform(_, property) {
-    return 'xml:' + property.slice(3).toLowerCase()
-  }
-});
-
-/**
- * Special cases for React (`Record<string, string>`).
- *
- * `hast` is close to `React` but differs in a couple of cases.
- * To get a React property from a hast property,
- * check if it is in `hastToReact`.
- * If it is, use the corresponding value;
- * otherwise, use the hast property.
- *
- * @type {Record<string, string>}
- */
-const hastToReact = {
-  classId: 'classID',
-  dataType: 'datatype',
-  itemId: 'itemID',
-  strokeDashArray: 'strokeDasharray',
-  strokeDashOffset: 'strokeDashoffset',
-  strokeLineCap: 'strokeLinecap',
-  strokeLineJoin: 'strokeLinejoin',
-  strokeMiterLimit: 'strokeMiterlimit',
-  typeOf: 'typeof',
-  xLinkActuate: 'xlinkActuate',
-  xLinkArcRole: 'xlinkArcrole',
-  xLinkHref: 'xlinkHref',
-  xLinkRole: 'xlinkRole',
-  xLinkShow: 'xlinkShow',
-  xLinkTitle: 'xlinkTitle',
-  xLinkType: 'xlinkType',
-  xmlnsXLink: 'xmlnsXlink'
-};
-
 /**
- * @import {Schema} from 'property-information'
+ * @typedef {import('./util/schema.js').Schema} Schema
  */
 
 
-const cap$1 = /[A-Z]/g;
-const dash = /-[a-z]/g;
 const valid = /^data[-\w.:]+$/i;
+const dash = /-[a-z]/g;
+const cap$1 = /[A-Z]/g;
 
 /**
- * Look up info on a property.
- *
- * In most cases the given `schema` contains info on the property.
- * All standard,
- * most legacy,
- * and some non-standard properties are supported.
- * For these cases,
- * the returned `Info` has hints about the value of the property.
- *
- * `name` can also be a valid data attribute or property,
- * in which case an `Info` object with the correctly cased `attribute` and
- * `property` is returned.
- *
- * `name` can be an unknown attribute,
- * in which case an `Info` object with `attribute` and `property` set to the
- * given name is returned.
- * It is not recommended to provide unsupported legacy or recently specced
- * properties.
- *
- *
  * @param {Schema} schema
- *   Schema;
- *   either the `html` or `svg` export.
  * @param {string} value
- *   An attribute-like or property-like name;
- *   it will be passed through `normalize` to hopefully find the correct info.
  * @returns {Info}
- *   Info.
  */
 function find(schema, value) {
   const normal = normalize$1(value);
-  let property = value;
+  let prop = value;
   let Type = Info;
 
   if (normal in schema.normal) {
@@ -1405,7 +1325,7 @@ function find(schema, value) {
     if (value.charAt(4) === '-') {
       // Turn it into a property.
       const rest = value.slice(5).replace(dash, camelcase);
-      property = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1);
+      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1);
     } else {
       // Turn it into an attribute.
       const rest = value.slice(4);
@@ -1424,14 +1344,12 @@ function find(schema, value) {
     Type = DefinedInfo;
   }
 
-  return new Type(property, value)
+  return new Type(prop, value)
 }
 
 /**
  * @param {string} $0
- *   Value.
  * @returns {string}
- *   Kebab.
  */
 function kebab($0) {
   return '-' + $0.toLowerCase()
@@ -1439,19 +1357,48 @@ function kebab($0) {
 
 /**
  * @param {string} $0
- *   Value.
  * @returns {string}
- *   Camel.
  */
 function camelcase($0) {
   return $0.charAt(1).toUpperCase()
 }
 
-// Note: types exposed from `index.d.ts`.
+/**
+ * `hast` is close to `React`, but differs in a couple of cases.
+ *
+ * To get a React property from a hast property, check if it is in
+ * `hastToReact`, if it is, then use the corresponding value,
+ * otherwise, use the hast property.
+ *
+ * @type {Record<string, string>}
+ */
+const hastToReact = {
+  classId: 'classID',
+  dataType: 'datatype',
+  itemId: 'itemID',
+  strokeDashArray: 'strokeDasharray',
+  strokeDashOffset: 'strokeDashoffset',
+  strokeLineCap: 'strokeLinecap',
+  strokeLineJoin: 'strokeLinejoin',
+  strokeMiterLimit: 'strokeMiterlimit',
+  typeOf: 'typeof',
+  xLinkActuate: 'xlinkActuate',
+  xLinkArcRole: 'xlinkArcrole',
+  xLinkHref: 'xlinkHref',
+  xLinkRole: 'xlinkRole',
+  xLinkShow: 'xlinkShow',
+  xLinkTitle: 'xlinkTitle',
+  xLinkType: 'xlinkType',
+  xmlnsXLink: 'xmlnsXlink'
+};
 
-const html$1 = merge([aria, html$2, xlink, xmlns, xml], 'html');
+/**
+ * @typedef {import('./lib/util/info.js').Info} Info
+ * @typedef {import('./lib/util/schema.js').Schema} Schema
+ */
 
-const svg = merge([aria, svg$1, xlink, xmlns, xml], 'svg');
+const html$1 = merge([xml, xlink, xmlns, aria, html$2], 'html');
+const svg = merge([xml, xlink, xmlns, aria, svg$1], 'svg');
 
 /**
  * Parse space-separated tokens to an array of strings.
@@ -1474,7 +1421,7 @@ function stringify(values) {
   return values.join(' ').trim()
 }
 
-var cjs$2 = {};
+var cjs = {};
 
 // http://www.w3.org/TR/CSS21/grammar.html
 // https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
@@ -1509,7 +1456,7 @@ var TYPE_DECLARATION = 'declaration';
  * @throws {TypeError}
  * @throws {Error}
  */
-function index$1 (style, options) {
+var inlineStyleParser = function (style, options) {
   if (typeof style !== 'string') {
     throw new TypeError('First argument must be a string');
   }
@@ -1722,7 +1669,7 @@ function index$1 (style, options) {
 
   whitespace();
   return declarations();
-}
+};
 
 /**
  * Trim `str`.
@@ -1734,14 +1681,12 @@ function trim(str) {
   return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
 }
 
-var cjs$1 = index$1;
-
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(cjs$2, "__esModule", { value: true });
-cjs$2.default = StyleToObject;
-const inline_style_parser_1 = __importDefault$1(cjs$1);
+Object.defineProperty(cjs, "__esModule", { value: true });
+var _default = cjs.default = StyleToObject;
+var inline_style_parser_1 = __importDefault(inlineStyleParser);
 /**
  * Parses inline style to object.
  *
@@ -1757,17 +1702,17 @@ const inline_style_parser_1 = __importDefault$1(cjs$1);
  * ```
  */
 function StyleToObject(style, iterator) {
-    let styleObject = null;
+    var styleObject = null;
     if (!style || typeof style !== 'string') {
         return styleObject;
     }
-    const declarations = (0, inline_style_parser_1.default)(style);
-    const hasIterator = typeof iterator === 'function';
-    declarations.forEach((declaration) => {
+    var declarations = (0, inline_style_parser_1.default)(style);
+    var hasIterator = typeof iterator === 'function';
+    declarations.forEach(function (declaration) {
         if (declaration.type !== 'declaration') {
             return;
         }
-        const { property, value } = declaration;
+        var property = declaration.property, value = declaration.value;
         if (hasIterator) {
             iterator(property, value, declaration);
         }
@@ -1779,80 +1724,8 @@ function StyleToObject(style, iterator) {
     return styleObject;
 }
 
-var utilities = {};
-
-Object.defineProperty(utilities, "__esModule", { value: true });
-utilities.camelCase = void 0;
-var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
-var HYPHEN_REGEX = /-([a-z])/g;
-var NO_HYPHEN_REGEX = /^[^-]+$/;
-var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
-var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
-/**
- * Checks whether to skip camelCase.
- */
-var skipCamelCase = function (property) {
-    return !property ||
-        NO_HYPHEN_REGEX.test(property) ||
-        CUSTOM_PROPERTY_REGEX.test(property);
-};
-/**
- * Replacer that capitalizes first character.
- */
-var capitalize = function (match, character) {
-    return character.toUpperCase();
-};
-/**
- * Replacer that removes beginning hyphen of vendor prefix property.
- */
-var trimHyphen = function (match, prefix) { return "".concat(prefix, "-"); };
-/**
- * CamelCases a CSS property.
- */
-var camelCase = function (property, options) {
-    if (options === void 0) { options = {}; }
-    if (skipCamelCase(property)) {
-        return property;
-    }
-    property = property.toLowerCase();
-    if (options.reactCompat) {
-        // `-ms` vendor prefix should not be capitalized
-        property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
-    }
-    else {
-        // for non-React, remove first hyphen so vendor prefix is not capitalized
-        property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
-    }
-    return property.replace(HYPHEN_REGEX, capitalize);
-};
-utilities.camelCase = camelCase;
-
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var style_to_object_1 = __importDefault(cjs$2);
-var utilities_1 = utilities;
-/**
- * Parses CSS inline style to JavaScript object (camelCased).
- */
-function StyleToJS(style, options) {
-    var output = {};
-    if (!style || typeof style !== 'string') {
-        return output;
-    }
-    (0, style_to_object_1.default)(style, function (property, value) {
-        // skip CSS comment
-        if (property && value) {
-            output[(0, utilities_1.camelCase)(property, options)] = value;
-        }
-    });
-    return output;
-}
-StyleToJS.default = StyleToJS;
-var cjs = StyleToJS;
-
-
-var styleToJs = /*@__PURE__*/getDefaultExportFromCjs(cjs);
+// ensure compatibility with rollup umd build
+var styleToObject = _default.default || _default;
 
 /**
  * @typedef {import('unist').Node} Node
@@ -2340,7 +2213,7 @@ VFileMessage.prototype.source = undefined;
  * @import {MdxJsxFlowElementHast, MdxJsxTextElementHast} from 'mdast-util-mdx-jsx'
  * @import {MdxjsEsmHast} from 'mdast-util-mdxjs-esm'
  * @import {Position} from 'unist'
- * @import {Child, Create, Field, JsxElement, State, Style} from './types.js'
+ * @import {Child, Create, Field, State, Style} from './types.js'
  */
 
 
@@ -2351,6 +2224,7 @@ const own$4 = {}.hasOwnProperty;
 const emptyMap = new Map();
 
 const cap = /[A-Z]/g;
+const dashSomething = /-([a-z])/g;
 
 // `react-dom` triggers a warning for *any* white space in tables.
 // To follow GFM, `mdast-util-to-hast` injects line endings between elements.
@@ -2377,7 +2251,7 @@ const docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime';
  *   Tree to transform.
  * @param {Options} options
  *   Configuration (required).
- * @returns {JsxElement}
+ * @returns {JSX.Element}
  *   JSX element.
  */
 
@@ -2959,24 +2833,49 @@ function createProperty(state, prop, value) {
  *   Throws `VFileMessage` when CSS cannot be parsed.
  */
 function parseStyle(state, value) {
+  /** @type {Style} */
+  const result = {};
+
   try {
-    return styleToJs(value, {reactCompat: true})
+    styleToObject(value, replacer);
   } catch (error) {
-    if (state.ignoreInvalidStyle) {
-      return {}
+    if (!state.ignoreInvalidStyle) {
+      const cause = /** @type {Error} */ (error);
+      const message = new VFileMessage('Cannot parse `style` attribute', {
+        ancestors: state.ancestors,
+        cause,
+        ruleId: 'style',
+        source: 'hast-util-to-jsx-runtime'
+      });
+      message.file = state.filePath || undefined;
+      message.url = docs + '#cannot-parse-style-attribute';
+
+      throw message
     }
+  }
 
-    const cause = /** @type {Error} */ (error);
-    const message = new VFileMessage('Cannot parse `style` attribute', {
-      ancestors: state.ancestors,
-      cause,
-      ruleId: 'style',
-      source: 'hast-util-to-jsx-runtime'
-    });
-    message.file = state.filePath || undefined;
-    message.url = docs + '#cannot-parse-style-attribute';
+  return result
 
-    throw message
+  /**
+   * Add a CSS property (normal, so with dashes) to `result` as a DOM CSS
+   * property.
+   *
+   * @param {string} name
+   *   Key.
+   * @param {string} value
+   *   Value
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function replacer(name, value) {
+    let key = name;
+
+    if (key.slice(0, 2) !== '--') {
+      if (key.slice(0, 4) === '-ms-') key = 'ms-' + key.slice(4);
+      key = key.replace(dashSomething, toCamel);
+    }
+
+    result[key] = value;
   }
 }
 
@@ -3030,7 +2929,8 @@ function findComponentFromName(state, name$1, allowExpression) {
   // Only literals can be passed in `components` currently.
   // No identifiers / member expressions.
   if (result.type === 'Literal') {
-    const name = /** @type {string | number} */ (result.value);
+    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value);
+
     return own$4.call(state.components, name) ? state.components[name] : name
   }
 
@@ -3097,6 +2997,20 @@ function transformStyleToCssCasing(from) {
   return to
 }
 
+/**
+ * Make `$1` capitalized.
+ *
+ * @param {string} _
+ *   Whatever.
+ * @param {string} $1
+ *   Single ASCII alphabetical.
+ * @returns {string}
+ *   Capitalized `$1`.
+ */
+function toCamel(_, $1) {
+  return $1.toUpperCase()
+}
+
 /**
  * Make `$0` dash cased.
  *
@@ -5383,7 +5297,6 @@ const characterEntities = {
   zwnj: '‌'
 };
 
-// To do: next major: use `Object.hasOwn`.
 const own$3 = {}.hasOwnProperty;
 
 /**
@@ -14055,7 +13968,7 @@ const own$2 = {}.hasOwnProperty;
  *   mdast tree.
  */
 function fromMarkdown(value, encoding, options) {
-  if (encoding && typeof encoding === 'object') {
+  if (typeof encoding !== 'string') {
     options = encoding;
     encoding = undefined;
   }
@@ -15197,11 +15110,12 @@ function remarkParse(options) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Blockquote} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `blockquote` node into hast.
  *
@@ -15225,11 +15139,13 @@ function blockquote(state, node) {
 }
 
 /**
- * @import {Element, Text} from 'hast'
- * @import {Break} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').Break} Break
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `break` node into hast.
  *
@@ -15248,11 +15164,13 @@ function hardBreak(state, node) {
 }
 
 /**
- * @import {Element, Properties} from 'hast'
- * @import {Code} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `code` node into hast.
  *
@@ -15267,12 +15185,9 @@ function code(state, node) {
   const value = node.value ? node.value + '\n' : '';
   /** @type {Properties} */
   const properties = {};
-  // Someone can write `js&#x20;python&#x9;ruby`.
-  const language = node.lang ? node.lang.split(/\s+/) : [];
 
-  // GH/CM still drop the non-first languages.
-  if (language.length > 0) {
-    properties.className = ['language-' + language[0]];
+  if (node.lang) {
+    properties.className = ['language-' + node.lang];
   }
 
   // Create `<code>`.
@@ -15298,11 +15213,12 @@ function code(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Delete} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Delete} Delete
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `delete` node into hast.
  *
@@ -15326,11 +15242,12 @@ function strikethrough(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Emphasis} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `emphasis` node into hast.
  *
@@ -15354,9 +15271,9 @@ function emphasis(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {FootnoteReference} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').FootnoteReference} FootnoteReference
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -15424,11 +15341,12 @@ function footnoteReference(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Heading} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `heading` node into hast.
  *
@@ -15452,12 +15370,13 @@ function heading(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Html} from 'mdast'
- * @import {State} from '../state.js'
- * @import {Raw} from '../../index.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Html} Html
+ * @typedef {import('../state.js').State} State
+ * @typedef {import('../../index.js').Raw} Raw
  */
 
+
 /**
  * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
  * nothing).
@@ -15481,11 +15400,15 @@ function html(state, node) {
 }
 
 /**
- * @import {ElementContent} from 'hast'
- * @import {Reference, Nodes} from 'mdast'
- * @import {State} from './state.js'
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast').Reference} Reference
+ *
+ * @typedef {import('./state.js').State} State
  */
 
+
 /**
  * Return the content of a reference without definition as plain text.
  *
@@ -15531,9 +15454,11 @@ function revert(state, node) {
 }
 
 /**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {ImageReference} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').ImageReference} ImageReference
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -15569,9 +15494,10 @@ function imageReference(state, node) {
 }
 
 /**
- * @import {Element, Properties} from 'hast'
- * @import {Image} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -15604,11 +15530,13 @@ function image(state, node) {
 }
 
 /**
- * @import {Element, Text} from 'hast'
- * @import {InlineCode} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `inlineCode` node into hast.
  *
@@ -15636,9 +15564,11 @@ function inlineCode(state, node) {
 }
 
 /**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {LinkReference} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').LinkReference} LinkReference
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -15679,9 +15609,10 @@ function linkReference(state, node) {
 }
 
 /**
- * @import {Element, Properties} from 'hast'
- * @import {Link} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -15715,11 +15646,15 @@ function link(state, node) {
 }
 
 /**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {ListItem, Parents} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `listItem` node into hast.
  *
@@ -15835,11 +15770,13 @@ function listItemLoose(node) {
 }
 
 /**
- * @import {Element, Properties} from 'hast'
- * @import {List} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `list` node into hast.
  *
@@ -15888,11 +15825,12 @@ function list(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Paragraph} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `paragraph` node into hast.
  *
@@ -15916,11 +15854,13 @@ function paragraph(state, node) {
 }
 
 /**
- * @import {Parents as HastParents, Root as HastRoot} from 'hast'
- * @import {Root as MdastRoot} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Parents} HastParents
+ * @typedef {import('hast').Root} HastRoot
+ * @typedef {import('mdast').Root} MdastRoot
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `root` node into hast.
  *
@@ -15939,11 +15879,12 @@ function root(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {Strong} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `strong` node into hast.
  *
@@ -15967,9 +15908,9 @@ function strong(state, node) {
 }
 
 /**
- * @import {Table} from 'mdast'
- * @import {Element} from 'hast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -16028,11 +15969,15 @@ function table(state, node) {
 }
 
 /**
- * @import {Element, ElementContent, Properties} from 'hast'
- * @import {Parents, TableRow} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('mdast').TableRow} TableRow
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `tableRow` node into hast.
  *
@@ -16092,11 +16037,12 @@ function tableRow(state, node, parent) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {TableCell} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `tableCell` node into hast.
  *
@@ -16192,9 +16138,10 @@ function trimLine(value, start, end) {
 }
 
 /**
- * @import {Element as HastElement, Text as HastText} from 'hast'
- * @import {Text as MdastText} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').Text} HastText
+ * @typedef {import('mdast').Text} MdastText
+ * @typedef {import('../state.js').State} State
  */
 
 
@@ -16216,11 +16163,12 @@ function text(state, node) {
 }
 
 /**
- * @import {Element} from 'hast'
- * @import {ThematicBreak} from 'mdast'
- * @import {State} from '../state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ * @typedef {import('../state.js').State} State
  */
 
+
 /**
  * Turn an mdast `thematicBreak` node into hast.
  *
@@ -16243,15 +16191,10 @@ function thematicBreak(state, node) {
   return state.applyData(node, result)
 }
 
-/**
- * @import {Handlers} from '../state.js'
- */
-
-
 /**
  * Default handlers for nodes.
  *
- * @satisfies {Handlers}
+ * @satisfies {import('../state.js').Handlers}
  */
 const handlers = {
   blockquote,
@@ -16356,12 +16299,6 @@ const deserializer = ($, _) => {
         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);
   };
@@ -16404,8 +16341,6 @@ const typeOf = value => {
       return [MAP, EMPTY];
     case 'Set':
       return [SET, EMPTY];
-    case 'DataView':
-      return [ARRAY, asString];
   }
 
   if (asString.includes('Array'))
@@ -16455,17 +16390,9 @@ const serializer = (strict, json, $, _) => {
         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);
-        }
-
+        if (type)
+          return as([type, [...value]], value);
+  
         const arr = [];
         const index = as([TYPE, arr], value);
         for (const entry of value)
@@ -16566,8 +16493,10 @@ var structuredClone$1 = typeof structuredClone === "function" ?
   (any, options) => deserialize(serialize(any, options));
 
 /**
- * @import {ElementContent, Element} from 'hast'
- * @import {State} from './state.js'
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('./state.js').State} State
  */
 
 
@@ -17215,25 +17144,22 @@ function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
 }
 
 /**
- * @import {
- *   ElementContent as HastElementContent,
- *   Element as HastElement,
- *   Nodes as HastNodes,
- *   Properties as HastProperties,
- *   RootContent as HastRootContent,
- *   Text as HastText
- * } from 'hast'
- * @import {
- *   Definition as MdastDefinition,
- *   FootnoteDefinition as MdastFootnoteDefinition,
- *   Nodes as MdastNodes,
- *   Parents as MdastParents
- * } from 'mdast'
- * @import {VFile} from 'vfile'
- * @import {
- *   FootnoteBackContentTemplate,
- *   FootnoteBackLabelTemplate
- * } from './footer.js'
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').ElementContent} HastElementContent
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('hast').Properties} HastProperties
+ * @typedef {import('hast').RootContent} HastRootContent
+ * @typedef {import('hast').Text} HastText
+ *
+ * @typedef {import('mdast').Definition} MdastDefinition
+ * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('mdast').Parents} MdastParents
+ *
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate
+ * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate
  */
 
 
@@ -17533,9 +17459,9 @@ function trimMarkdownSpaceStart(value) {
 }
 
 /**
- * @import {Nodes as HastNodes} from 'hast'
- * @import {Nodes as MdastNodes} from 'mdast'
- * @import {Options} from './state.js'
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('./state.js').Options} Options
  */
 
 
@@ -17855,7 +17781,7 @@ var getProperty = function getProperty(obj, name) {
 	return obj[name];
 };
 
-var extend$1 = function extend() {
+var extend = function extend() {
 	var options, name, src, copy, copyIsArray, clone;
 	var target = arguments[0];
 	var i = 1;
@@ -17909,7 +17835,7 @@ var extend$1 = function extend() {
 	return target;
 };
 
-var extend = /*@__PURE__*/getDefaultExportFromCjs(extend$1);
+var extend$1 = /*@__PURE__*/getDefaultExportFromCjs(extend);
 
 function isPlainObject(value) {
 	if (typeof value !== 'object' || value === null) {
@@ -19514,7 +19440,7 @@ class Processor extends CallableInstance {
       destination.use(...attacher);
     }
 
-    destination.data(extend(true, {}, this.namespace));
+    destination.data(extend$1(true, {}, this.namespace));
 
     return destination
   }
@@ -20112,7 +20038,7 @@ class Processor extends CallableInstance {
       addList(result.plugins);
 
       if (result.settings) {
-        namespace.settings = extend(true, namespace.settings, result.settings);
+        namespace.settings = extend$1(true, namespace.settings, result.settings);
       }
     }
 
@@ -20158,7 +20084,7 @@ class Processor extends CallableInstance {
         let [primary, ...rest] = parameters;
         const currentPrimary = attachers[entryIndex][1];
         if (isPlainObject(currentPrimary) && isPlainObject(primary)) {
-          primary = extend(true, currentPrimary, primary);
+          primary = extend$1(true, currentPrimary, primary);
         }
 
         attachers[entryIndex] = [plugin, primary, ...rest];