@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/pipeline/transformMarkdownCode/transformMarkdownCode.js

@@ -1,6 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { visit } from 'unist-util-visit';
 import { normalizeLanguage } from "../loaderUtils/getLanguageFromExtension.js";
 
@@ -93,26 +90,22 @@ function getFileName(props) {
  * Parse meta string to extract variant and other properties
  */
 function parseMeta(meta) {
-  var result = {
+  const result = {
     props: {}
   };
 
   // Parse key=value pairs first, handling quoted values
-  var keyValueRegex = /([\w-]+)=("(?:[^"\\]|\\.)*"|[^\s]+)/g;
-  var match = keyValueRegex.exec(meta);
-  var processedPositions = [];
+  const keyValueRegex = /([\w-]+)=("(?:[^"\\]|\\.)*"|[^\s]+)/g;
+  let match = keyValueRegex.exec(meta);
+  const processedPositions = [];
   while (match !== null) {
-    var _match = match,
-      _match2 = _slicedToArray(_match, 3),
-      fullMatch = _match2[0],
-      key = _match2[1],
-      rawValue = _match2[2];
-    var startPos = match.index;
-    var endPos = match.index + fullMatch.length;
+    const [fullMatch, key, rawValue] = match;
+    const startPos = match.index;
+    const endPos = match.index + fullMatch.length;
     processedPositions.push([startPos, endPos]);
 
     // Remove quotes if present
-    var value = rawValue.startsWith('"') && rawValue.endsWith('"') ? rawValue.slice(1, -1) : rawValue;
+    const value = rawValue.startsWith('"') && rawValue.endsWith('"') ? rawValue.slice(1, -1) : rawValue;
     if (key === 'variant') {
       result.variant = value;
     } else if (key === 'variant-type') {
@@ -124,46 +117,32 @@ function parseMeta(meta) {
   }
 
   // Extract remaining parts as standalone flags
-  var remainingMeta = meta;
+  let remainingMeta = meta;
   // Remove processed key=value pairs from the string (in reverse order to maintain positions)
-  processedPositions.sort(function (a, b) {
-    return b[0] - a[0];
-  }).forEach(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      start = _ref2[0],
-      end = _ref2[1];
+  processedPositions.sort((a, b) => b[0] - a[0]).forEach(([start, end]) => {
     remainingMeta = remainingMeta.slice(0, start) + remainingMeta.slice(end);
   });
 
   // Process remaining standalone flags
-  var remainingParts = remainingMeta.trim().split(/\s+/).filter(Boolean);
-  var _iterator = _createForOfIteratorHelper(remainingParts),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var part = _step.value;
-      if (part === 'variant') {
-        // This shouldn't happen, but just in case
-        result.variant = 'true';
-      } else if (part === 'variant-type') {
-        // This shouldn't happen, but just in case
-        result.variantType = 'true';
-      } else {
-        // Handle standalone flags (e.g., "transform" becomes "transform": "true")
-        result.props[part] = 'true';
-      }
+  const remainingParts = remainingMeta.trim().split(/\s+/).filter(Boolean);
+  for (const part of remainingParts) {
+    if (part === 'variant') {
+      // This shouldn't happen, but just in case
+      result.variant = 'true';
+    } else if (part === 'variant-type') {
+      // This shouldn't happen, but just in case
+      result.variantType = 'true';
+    } else {
+      // Handle standalone flags (e.g., "transform" becomes "transform": "true")
+      result.props[part] = 'true';
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return result;
 }
-export var transformMarkdownCode = function transformMarkdownCode() {
-  return function (tree) {
-    var processedIndices = new Set();
-    visit(tree, function (node, index, parent) {
+export const transformMarkdownCode = () => {
+  return tree => {
+    const processedIndices = new Set();
+    visit(tree, (node, index, parent) => {
       if (!parent || !Array.isArray(parent.children) || typeof index !== 'number') {
         return;
       }
@@ -172,15 +151,15 @@ export var transformMarkdownCode = function transformMarkdownCode() {
       if (processedIndices.has(index)) {
         return;
       }
-      var parentNode = parent;
+      const parentNode = parent;
 
       // Look for code blocks with variant metadata or options
       if (node.type === 'code') {
-        var codeNode = node;
+        const codeNode = node;
 
         // Check if variant metadata is in meta field or lang field (when no language is specified)
-        var metaString = codeNode.meta;
-        var langFromMeta = codeNode.lang || null;
+        let metaString = codeNode.meta;
+        let langFromMeta = codeNode.lang || null;
 
         // If meta is empty but lang contains '=', it means variant info is in lang
         if (!metaString && codeNode.lang && codeNode.lang.includes('=')) {
@@ -189,7 +168,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
         }
 
         // Check if we have variants/variant-types or individual options
-        var metaData = {
+        let metaData = {
           props: {}
         };
         if (metaString) {
@@ -197,32 +176,27 @@ export var transformMarkdownCode = function transformMarkdownCode() {
         }
 
         // Use props from meta as the options for individual blocks
-        var allProps = metaData.props;
+        const allProps = metaData.props;
 
         // Handle individual code blocks with options (but no variants)
         if (!metaData.variant && !metaData.variantType && Object.keys(allProps).length > 0) {
-          var codeHProperties = {};
+          const codeHProperties = {};
 
           // Add normalized language as class
           if (langFromMeta) {
-            codeHProperties.className = "language-".concat(normalizeLanguage(langFromMeta));
+            codeHProperties.className = `language-${normalizeLanguage(langFromMeta)}`;
           }
 
           // Add all props as data attributes (in camelCase)
-          Object.entries(allProps).forEach(function (_ref3) {
-            var _ref4 = _slicedToArray(_ref3, 2),
-              key = _ref4[0],
-              value = _ref4[1];
+          Object.entries(allProps).forEach(([key, value]) => {
             // Convert kebab-case to camelCase for data attributes
-            var camelKey = key.includes('-') ? "data".concat(key.split('-').map(function (part) {
-              return part.charAt(0).toUpperCase() + part.slice(1);
-            }).join('')) : "data".concat(key.charAt(0).toUpperCase() + key.slice(1));
+            const camelKey = key.includes('-') ? `data${key.split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('')}` : `data${key.charAt(0).toUpperCase() + key.slice(1)}`;
             codeHProperties[camelKey] = value;
           });
-          var fileName = getFileName(allProps);
+          const fileName = getFileName(allProps);
 
           // Create pre > code element
-          var preElement = {
+          const preElement = {
             type: 'element',
             tagName: 'pre',
             data: {
@@ -245,7 +219,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
 
           // If there's a filename, wrap in dl/dt/dd structure
           // Otherwise, just use pre > code directly
-          var outputElement = fileName ? {
+          const outputElement = fileName ? {
             type: 'element',
             tagName: 'dl',
             data: {
@@ -294,24 +268,24 @@ export var transformMarkdownCode = function transformMarkdownCode() {
         }
         if (metaData.variant || metaData.variantType) {
           // Collect consecutive code blocks that belong together
-          var codeBlocks = [];
-          var currentIndex = index;
+          const codeBlocks = [];
+          let currentIndex = index;
 
           // For variant-type, look for pattern: [label] -> code block
           // For variant, look for adjacent code blocks only
 
           if (metaData.variantType) {
             // Add the current code block as the first one for variant-type
-            var currentLabelFromPrevious;
+            let currentLabelFromPrevious;
             if (index > 0) {
-              var prevNode = parentNode.children[index - 1];
+              const prevNode = parentNode.children[index - 1];
               if (prevNode.type === 'paragraph' && prevNode.children.length === 1 && prevNode.children[0].type === 'text') {
                 currentLabelFromPrevious = prevNode.children[0].value.trim();
               }
             }
             codeBlocks.push({
               node: codeNode,
-              index: index,
+              index,
               variant: currentLabelFromPrevious || metaData.variantType || 'default',
               props: allProps,
               actualLang: langFromMeta,
@@ -324,32 +298,32 @@ export var transformMarkdownCode = function transformMarkdownCode() {
 
             // Collect all blocks with the same variant-type
             while (currentIndex < parentNode.children.length) {
-              var currentNode = parentNode.children[currentIndex];
+              const currentNode = parentNode.children[currentIndex];
 
               // Check if this is a potential label paragraph
               if (currentNode.type === 'paragraph' && currentNode.children.length === 1 && currentNode.children[0].type === 'text') {
                 // Look for a code block after this paragraph
                 if (currentIndex + 1 < parentNode.children.length) {
-                  var nextNode = parentNode.children[currentIndex + 1];
+                  const nextNode = parentNode.children[currentIndex + 1];
                   if (nextNode.type === 'code') {
                     // Check if this code block has the same variant-type
-                    var nextMetaString = nextNode.meta;
-                    var nextActualLang = nextNode.lang;
+                    let nextMetaString = nextNode.meta;
+                    let nextActualLang = nextNode.lang;
                     if (!nextMetaString && nextActualLang && nextActualLang.includes('=')) {
                       nextMetaString = nextActualLang;
                       nextActualLang = null;
                     }
                     if (nextMetaString) {
-                      var nextMetaData = parseMeta(nextMetaString);
+                      const nextMetaData = parseMeta(nextMetaString);
                       if (nextMetaData.variantType === metaData.variantType) {
-                        var labelFromPrevious = currentNode.children[0].value.trim();
+                        const labelFromPrevious = currentNode.children[0].value.trim();
                         codeBlocks.push({
                           node: nextNode,
                           index: currentIndex + 1,
                           variant: labelFromPrevious || nextMetaData.variantType || 'default',
                           props: nextMetaData.props,
                           actualLang: nextActualLang,
-                          labelFromPrevious: labelFromPrevious
+                          labelFromPrevious
                         });
                         processedIndices.add(currentIndex + 1);
 
@@ -365,30 +339,30 @@ export var transformMarkdownCode = function transformMarkdownCode() {
               }
               if (currentNode.type === 'code') {
                 // Parse language and meta for current node
-                var currentMetaString = currentNode.meta;
-                var currentActualLang = currentNode.lang;
+                let currentMetaString = currentNode.meta;
+                let currentActualLang = currentNode.lang;
                 if (!currentMetaString && currentActualLang && currentActualLang.includes('=')) {
                   currentMetaString = currentActualLang;
                   currentActualLang = null;
                 }
                 if (currentMetaString) {
-                  var currentMetaData = parseMeta(currentMetaString);
+                  const currentMetaData = parseMeta(currentMetaString);
                   if (currentMetaData.variantType === metaData.variantType) {
                     // Look for label before this code block
-                    var _labelFromPrevious = void 0;
+                    let labelFromPrevious;
                     if (currentIndex > 0) {
-                      var _prevNode = parentNode.children[currentIndex - 1];
-                      if (_prevNode.type === 'paragraph' && _prevNode.children.length === 1 && _prevNode.children[0].type === 'text') {
-                        _labelFromPrevious = _prevNode.children[0].value.trim();
+                      const prevNode = parentNode.children[currentIndex - 1];
+                      if (prevNode.type === 'paragraph' && prevNode.children.length === 1 && prevNode.children[0].type === 'text') {
+                        labelFromPrevious = prevNode.children[0].value.trim();
                       }
                     }
                     codeBlocks.push({
                       node: currentNode,
                       index: currentIndex,
-                      variant: _labelFromPrevious || currentMetaData.variantType || 'default',
+                      variant: labelFromPrevious || currentMetaData.variantType || 'default',
                       props: currentMetaData.props,
                       actualLang: currentActualLang,
-                      labelFromPrevious: _labelFromPrevious
+                      labelFromPrevious
                     });
                     processedIndices.add(currentIndex);
 
@@ -397,8 +371,8 @@ export var transformMarkdownCode = function transformMarkdownCode() {
 
                     // Skip ahead past any paragraph that could be a label
                     if (currentIndex < parentNode.children.length) {
-                      var _nextNode = parentNode.children[currentIndex];
-                      if (_nextNode.type === 'paragraph' && _nextNode.children.length === 1 && _nextNode.children[0].type === 'text') {
+                      const nextNode = parentNode.children[currentIndex];
+                      if (nextNode.type === 'paragraph' && nextNode.children.length === 1 && nextNode.children[0].type === 'text') {
                         currentIndex += 1; // Skip the potential label
                       }
                     }
@@ -416,7 +390,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
             // Add the current code block as the first one for variant
             codeBlocks.push({
               node: codeNode,
-              index: index,
+              index,
               variant: metaData.variant,
               props: allProps,
               actualLang: langFromMeta
@@ -428,24 +402,24 @@ export var transformMarkdownCode = function transformMarkdownCode() {
 
             // Collect adjacent code blocks with variants
             while (currentIndex < parentNode.children.length) {
-              var _currentNode = parentNode.children[currentIndex];
-              if (_currentNode.type === 'code') {
+              const currentNode = parentNode.children[currentIndex];
+              if (currentNode.type === 'code') {
                 // Parse language and meta for current node
-                var _currentMetaString = _currentNode.meta;
-                var _currentActualLang = _currentNode.lang;
-                if (!_currentMetaString && _currentActualLang && _currentActualLang.includes('=')) {
-                  _currentMetaString = _currentActualLang;
-                  _currentActualLang = null;
+                let currentMetaString = currentNode.meta;
+                let currentActualLang = currentNode.lang;
+                if (!currentMetaString && currentActualLang && currentActualLang.includes('=')) {
+                  currentMetaString = currentActualLang;
+                  currentActualLang = null;
                 }
-                if (_currentMetaString) {
-                  var _currentMetaData = parseMeta(_currentMetaString);
-                  if (_currentMetaData.variant) {
+                if (currentMetaString) {
+                  const currentMetaData = parseMeta(currentMetaString);
+                  if (currentMetaData.variant) {
                     codeBlocks.push({
-                      node: _currentNode,
+                      node: currentNode,
                       index: currentIndex,
-                      variant: _currentMetaData.variant,
-                      props: _currentMetaData.props,
-                      actualLang: _currentActualLang
+                      variant: currentMetaData.variant,
+                      props: currentMetaData.props,
+                      actualLang: currentActualLang
                     });
                     processedIndices.add(currentIndex);
                     currentIndex += 1;
@@ -464,37 +438,32 @@ export var transformMarkdownCode = function transformMarkdownCode() {
           // Only process if we have multiple blocks
           if (codeBlocks.length > 1) {
             // Create section with figure elements for each variant
-            var sectionElement = {
+            const sectionElement = {
               type: 'element',
               tagName: 'section',
               data: {
                 hName: 'section',
                 hProperties: {}
               },
-              children: codeBlocks.map(function (block) {
+              children: codeBlocks.map(block => {
                 // Build hProperties for HTML attributes
-                var codeHProperties = {};
+                const codeHProperties = {};
 
                 // Add normalized language as class
                 if (block.actualLang) {
-                  codeHProperties.className = "language-".concat(normalizeLanguage(block.actualLang));
+                  codeHProperties.className = `language-${normalizeLanguage(block.actualLang)}`;
                 }
 
                 // Add additional props as data attributes (in camelCase)
-                Object.entries(block.props).forEach(function (_ref5) {
-                  var _ref6 = _slicedToArray(_ref5, 2),
-                    key = _ref6[0],
-                    value = _ref6[1];
+                Object.entries(block.props).forEach(([key, value]) => {
                   // Convert kebab-case to camelCase for data attributes
-                  var camelKey = key.includes('-') ? "data".concat(key.split('-').map(function (part) {
-                    return part.charAt(0).toUpperCase() + part.slice(1);
-                  }).join('')) : "data".concat(key.charAt(0).toUpperCase() + key.slice(1));
+                  const camelKey = key.includes('-') ? `data${key.split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('')}` : `data${key.charAt(0).toUpperCase() + key.slice(1)}`;
                   codeHProperties[camelKey] = value;
                 });
 
                 // Add data-variant to track the variant
                 codeHProperties.dataVariant = block.variant;
-                var fileName = getFileName(block.props);
+                const fileName = getFileName(block.props);
                 return {
                   type: 'element',
                   tagName: 'figure',
@@ -511,7 +480,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                     },
                     children: [{
                       type: 'text',
-                      value: "".concat(block.variant, " variant")
+                      value: `${block.variant} variant`
                     }]
                   }, {
                     type: 'element',
@@ -520,7 +489,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                       hName: 'dl',
                       hProperties: {}
                     },
-                    children: [].concat(_toConsumableArray(fileName ? [{
+                    children: [...(fileName ? [{
                       type: 'element',
                       tagName: 'dt',
                       data: {
@@ -539,7 +508,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                           value: fileName
                         }]
                       }]
-                    }] : []), [{
+                    }] : []), {
                       type: 'element',
                       tagName: 'dd',
                       data: {
@@ -559,12 +528,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                           data: {
                             hName: 'code',
                             hProperties: codeHProperties,
-                            meta: "variant=".concat(block.variant).concat(Object.entries(block.props).map(function (_ref7) {
-                              var _ref8 = _slicedToArray(_ref7, 2),
-                                key = _ref8[0],
-                                value = _ref8[1];
-                              return " ".concat(key, "=").concat(value);
-                            }).join(''))
+                            meta: `variant=${block.variant}${Object.entries(block.props).map(([key, value]) => ` ${key}=${value}`).join('')}`
                           },
                           children: [{
                             type: 'text',
@@ -572,7 +536,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                           }]
                         }]
                       }]
-                    }])
+                    }]
                   }]
                 };
               })
@@ -582,62 +546,48 @@ export var transformMarkdownCode = function transformMarkdownCode() {
             parentNode.children[codeBlocks[0].index] = sectionElement;
 
             // Remove all other code blocks and their labels (in reverse order to maintain indices)
-            var indicesToRemove = codeBlocks.slice(1).map(function (block) {
-              var indices = [block.index];
+            const indicesToRemove = codeBlocks.slice(1).map(block => {
+              const indices = [block.index];
               // Also include label paragraph if it exists
               if (block.labelFromPrevious && block.index > 0) {
-                var _prevNode2 = parentNode.children[block.index - 1];
-                if (_prevNode2.type === 'paragraph') {
+                const prevNode = parentNode.children[block.index - 1];
+                if (prevNode.type === 'paragraph') {
                   indices.push(block.index - 1);
                 }
               }
               return indices;
-            }).flat().sort(function (a, b) {
-              return b - a;
-            }); // Sort in descending order
+            }).flat().sort((a, b) => b - a); // Sort in descending order
 
             // Remove the marked indices
-            var _iterator2 = _createForOfIteratorHelper(indicesToRemove),
-              _step2;
-            try {
-              var _loop = function _loop() {
-                var removeIdx = _step2.value;
-                if (removeIdx < parentNode.children.length) {
-                  parentNode.children.splice(removeIdx, 1);
-                  // Update processed indices to account for removed elements
-                  var _updatedProcessedIndices = new Set();
-                  processedIndices.forEach(function (processedIdx) {
-                    if (processedIdx > removeIdx) {
-                      _updatedProcessedIndices.add(processedIdx - 1);
-                    } else if (processedIdx < removeIdx) {
-                      _updatedProcessedIndices.add(processedIdx);
-                    }
-                    // Don't add the removed index
-                  });
-                  processedIndices.clear();
-                  _updatedProcessedIndices.forEach(function (processedIdx) {
-                    processedIndices.add(processedIdx);
-                  });
-                }
-              };
-              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                _loop();
+            for (const removeIdx of indicesToRemove) {
+              if (removeIdx < parentNode.children.length) {
+                parentNode.children.splice(removeIdx, 1);
+                // Update processed indices to account for removed elements
+                const updatedProcessedIndices = new Set();
+                processedIndices.forEach(processedIdx => {
+                  if (processedIdx > removeIdx) {
+                    updatedProcessedIndices.add(processedIdx - 1);
+                  } else if (processedIdx < removeIdx) {
+                    updatedProcessedIndices.add(processedIdx);
+                  }
+                  // Don't add the removed index
+                });
+                processedIndices.clear();
+                updatedProcessedIndices.forEach(processedIdx => {
+                  processedIndices.add(processedIdx);
+                });
               }
-
-              // Also remove the label of the first block if it exists
-            } catch (err) {
-              _iterator2.e(err);
-            } finally {
-              _iterator2.f();
             }
+
+            // Also remove the label of the first block if it exists
             if (codeBlocks[0].labelFromPrevious && codeBlocks[0].index > 0) {
-              var labelIndex = codeBlocks[0].index - 1;
-              var _prevNode3 = parentNode.children[labelIndex];
-              if (_prevNode3 && _prevNode3.type === 'paragraph') {
+              const labelIndex = codeBlocks[0].index - 1;
+              const prevNode = parentNode.children[labelIndex];
+              if (prevNode && prevNode.type === 'paragraph') {
                 parentNode.children.splice(labelIndex, 1);
                 // Update processed indices
-                var updatedProcessedIndices = new Set();
-                processedIndices.forEach(function (processedIdx) {
+                const updatedProcessedIndices = new Set();
+                processedIndices.forEach(processedIdx => {
                   if (processedIdx > labelIndex) {
                     updatedProcessedIndices.add(processedIdx - 1);
                   } else if (processedIdx < labelIndex) {
@@ -645,44 +595,39 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                   }
                 });
                 processedIndices.clear();
-                updatedProcessedIndices.forEach(function (processedIdx) {
+                updatedProcessedIndices.forEach(processedIdx => {
                   processedIndices.add(processedIdx);
                 });
               }
             }
           } else if (codeBlocks.length === 1) {
             // Single code block with variant - create a simple dl without figure wrapper
-            var block = codeBlocks[0];
-            var _codeHProperties = {};
+            const block = codeBlocks[0];
+            const codeHProperties = {};
 
             // Add normalized language as class
             if (block.actualLang) {
-              _codeHProperties.className = "language-".concat(normalizeLanguage(block.actualLang));
+              codeHProperties.className = `language-${normalizeLanguage(block.actualLang)}`;
             }
 
             // Add additional props as data attributes (in camelCase)
-            Object.entries(block.props).forEach(function (_ref9) {
-              var _ref0 = _slicedToArray(_ref9, 2),
-                key = _ref0[0],
-                value = _ref0[1];
+            Object.entries(block.props).forEach(([key, value]) => {
               // Convert kebab-case to camelCase for data attributes
-              var camelKey = key.includes('-') ? "data".concat(key.split('-').map(function (part) {
-                return part.charAt(0).toUpperCase() + part.slice(1);
-              }).join('')) : "data".concat(key.charAt(0).toUpperCase() + key.slice(1));
-              _codeHProperties[camelKey] = value;
+              const camelKey = key.includes('-') ? `data${key.split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('')}` : `data${key.charAt(0).toUpperCase() + key.slice(1)}`;
+              codeHProperties[camelKey] = value;
             });
 
             // Add data-variant to track the variant
-            _codeHProperties.dataVariant = block.variant;
-            var _fileName = getFileName(block.props);
-            var dlElement = {
+            codeHProperties.dataVariant = block.variant;
+            const fileName = getFileName(block.props);
+            const dlElement = {
               type: 'element',
               tagName: 'dl',
               data: {
                 hName: 'dl',
                 hProperties: {}
               },
-              children: [].concat(_toConsumableArray(_fileName ? [{
+              children: [...(fileName ? [{
                 type: 'element',
                 tagName: 'dt',
                 data: {
@@ -698,10 +643,10 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                   },
                   children: [{
                     type: 'text',
-                    value: _fileName
+                    value: fileName
                   }]
                 }]
-              }] : []), [{
+              }] : []), {
                 type: 'element',
                 tagName: 'dd',
                 data: {
@@ -720,13 +665,8 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                     tagName: 'code',
                     data: {
                       hName: 'code',
-                      hProperties: _codeHProperties,
-                      meta: "variant=".concat(block.variant).concat(Object.entries(block.props).map(function (_ref1) {
-                        var _ref10 = _slicedToArray(_ref1, 2),
-                          key = _ref10[0],
-                          value = _ref10[1];
-                        return " ".concat(key, "=").concat(value);
-                      }).join(''))
+                      hProperties: codeHProperties,
+                      meta: `variant=${block.variant}${Object.entries(block.props).map(([key, value]) => ` ${key}=${value}`).join('')}`
                     },
                     children: [{
                       type: 'text',
@@ -734,7 +674,7 @@ export var transformMarkdownCode = function transformMarkdownCode() {
                     }]
                   }]
                 }]
-              }])
+              }]
             };
 
             // Replace this single code block