@readme/markdown 14.14.1 → 15.0.0

package/dist/processor/transform/mdxish/tables/gfm-cell-normalization.d.ts

@@ -0,0 +1,9 @@
+import type { Node, TableCell } from 'mdast';
+export declare const hasChildren: (node: Node) => node is Node & {
+    children: Node[];
+};
+/**
+ * Returns a copy of the cell's children with line breaks — `break` nodes and newlines inside
+ * text — rewritten to the `<br />` a single-line GFM pipe cell can carry.
+ */
+export declare const normalizeCellChildrenForGfm: (cell: TableCell) => TableCell["children"];

package/dist/render-fixture.node.js

@@ -275,7 +275,7 @@ function visit(tree, test, visitor, reverse) {
 
 /***/ }),
 
-/***/ 9762:
+/***/ 7644:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -349,7 +349,7 @@ exports["default"] = canonical;
 
 /***/ }),
 
-/***/ 7900:
+/***/ 4350:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -358,15 +358,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const canonical_1 = __importDefault(__webpack_require__(9762));
-const modes_1 = __webpack_require__(1412);
-const uppercase_1 = __importDefault(__webpack_require__(8892));
+const canonical_1 = __importDefault(__webpack_require__(7644));
+const modes_1 = __webpack_require__(1130);
+const uppercase_1 = __importDefault(__webpack_require__(3622));
 exports["default"] = { uppercase: uppercase_1.default, canonical: canonical_1.default, modes: modes_1.modes, getMode: modes_1.getMode };
 
 
 /***/ }),
 
-/***/ 1412:
+/***/ 1130:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -425,6 +425,7 @@ exports.modes = {
     node: 'javascript',
     macruby: 'ruby',
     markdown: 'gfm',
+    md: 'gfm',
     ml: ['mllike', 'text/x-ocaml'],
     mssql: ['sql', 'text/x-mssql'],
     mysql: ['sql', 'text/x-mysql'],
@@ -479,7 +480,7 @@ function getMode(lang) {
 
 /***/ }),
 
-/***/ 8892:
+/***/ 3622:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -20197,7 +20198,7 @@ const CONTINUE = true
 /**
  * Stop traversing immediately.
  */
-const EXIT = false
+const lib_EXIT = false
 
 /**
  * Do not traverse this node’s children.
@@ -20311,7 +20312,7 @@ function visitParents(tree, test, visitor, reverse) {
         // @ts-expect-error: `visitor` is now a visitor.
         result = toResult(visitor(node, parents))
 
-        if (result[0] === EXIT) {
+        if (result[0] === lib_EXIT) {
           return result
         }
       }
@@ -20328,7 +20329,7 @@ function visitParents(tree, test, visitor, reverse) {
 
             subresult = factory(child, offset, grandparents)()
 
-            if (subresult[0] === EXIT) {
+            if (subresult[0] === lib_EXIT) {
               return subresult
             }
 
@@ -34035,7 +34036,7 @@ function formatHeadingAsSetext(node, state) {
       node.type === 'break'
     ) {
       literalWithBreak = true
-      return EXIT
+      return lib_EXIT
     }
   })
 
@@ -52885,7 +52886,7 @@ const lib_CONTINUE = Symbol('continue')
 /**
  * Stop traversing immediately.
  */
-const lib_EXIT = Symbol('exit')
+const estree_util_visit_lib_EXIT = Symbol('exit')
 
 /**
  * Do not traverse this node’s children.
@@ -52945,7 +52946,7 @@ function estree_util_visit_lib_visit(tree, visitor) {
       /** @type {ActionTuple} */
       const result = enter ? lib_toResult(enter(node, key, index, parents)) : []
 
-      if (result[0] === lib_EXIT) {
+      if (result[0] === estree_util_visit_lib_EXIT) {
         return result
       }
 
@@ -52981,7 +52982,7 @@ function estree_util_visit_lib_visit(tree, visitor) {
                     cIndex,
                     grandparents
                   )()
-                  if (subresult[0] === lib_EXIT) return subresult
+                  if (subresult[0] === estree_util_visit_lib_EXIT) return subresult
                   cIndex =
                     typeof subresult[1] === 'number' ? subresult[1] : cIndex + 1
                 } else {
@@ -52990,7 +52991,7 @@ function estree_util_visit_lib_visit(tree, visitor) {
               }
             } else if (nodelike(value)) {
               const subresult = build(value, cKey, undefined, grandparents)()
-              if (subresult[0] === lib_EXIT) return subresult
+              if (subresult[0] === estree_util_visit_lib_EXIT) return subresult
             }
           }
         }
@@ -68773,7 +68774,7 @@ const hasNamedExport = (tree, name) => {
             node.data.estree.body[0].declaration.type === 'VariableDeclaration') {
             const { declarations } = node.data.estree.body[0].declaration;
             hasExport = !!declarations.find(declaration => 'name' in declaration.id && declaration.id.name === name);
-            return hasExport ? EXIT : CONTINUE;
+            return hasExport ? lib_EXIT : CONTINUE;
         }
     });
     return hasExport;
@@ -69274,7 +69275,7 @@ const compatibilityTransfomer = () => tree => {
     const trimEmphasis = (node) => {
         lib_visit(node, 'text', child => {
             child.value = child.value.trim();
-            return EXIT;
+            return lib_EXIT;
         });
         return node;
     };
@@ -86560,16 +86561,16 @@ const Code = (props) => {
 };
 /* harmony default export */ const components_Code = (Code);
 
-// EXTERNAL MODULE: ./node_modules/@readme/syntax-highlighter/dist-utils/index.js
-var dist_utils = __webpack_require__(7900);
-var dist_utils_default = /*#__PURE__*/__webpack_require__.n(dist_utils);
+// EXTERNAL MODULE: ./node_modules/@readme/syntax-highlighter/dist-utils/utils/index.js
+var utils = __webpack_require__(4350);
+var utils_default = /*#__PURE__*/__webpack_require__.n(utils);
 ;// ./components/CodeTabs/index.tsx
 
 
 
 
 let mermaid;
-const { uppercase } = (dist_utils_default());
+const { uppercase } = (utils_default());
 // Module-level queue that batches mermaid nodes across all CodeTabs instances into a
 // single mermaid.run() call. This is necessary because mermaid generates SVG element IDs
 // using Date.now(), which collides when multiple diagrams render in the same millisecond.
@@ -94607,11 +94608,6 @@ const looseHtmlEntityConstruct = {
     name: 'looseHtmlEntity',
     tokenize: tokenizeLooseHtmlEntity,
 };
-function resolveEntity(name) {
-    const input = `&${name};`;
-    const decoded = decode_decodeHTMLStrict(input);
-    return decoded !== input ? decoded : undefined;
-}
 function tokenizeLooseHtmlEntity(effects, ok, nok) {
     let length = 0;
     const start = (code) => {
@@ -94678,28 +94674,9 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
 }
 function exitLooseHtmlEntity(token) {
     const raw = this.sliceSerialize(token);
-    const entityChars = raw.slice(1);
-    if (entityChars.startsWith('#')) {
-        const decoded = resolveEntity(entityChars);
-        if (decoded) {
-            this.enter({ type: 'text', value: decoded }, token);
-            this.exit(token);
-            return;
-        }
-    }
-    else {
-        for (let len = entityChars.length; len >= 2; len -= 1) {
-            const candidate = entityChars.slice(0, len);
-            const decoded = resolveEntity(candidate);
-            if (decoded) {
-                const remainder = entityChars.slice(len);
-                this.enter({ type: 'text', value: decoded + remainder }, token);
-                this.exit(token);
-                return;
-            }
-        }
-    }
-    this.enter({ type: 'text', value: raw }, token);
+    // `decodeHTML` follows the HTML spec's legacy rules, where only a small
+    // whitelist of names may omit the semicolon, so `&partner_key` stays intact.
+    this.enter({ type: 'text', value: esm_decode_decodeHTML(raw) }, token);
     this.exit(token);
 }
 function looseHtmlEntity() {
@@ -94719,10 +94696,11 @@ function looseHtmlEntityFromMarkdown() {
 /**
  * Micromark extension for HTML entities without semicolons.
  *
- * Handles named entities (e.g. `&nbsp`, `&amp`, `&copy`), decimal numeric
- * references (e.g. `&#160`, `&#169`), and hex numeric references (e.g. `&#xa0`,
- * `&#xA0`). Entities that already include the semicolon are left for the
- * standard parser to handle.
+ * Handles the named entities the HTML spec lets authors write without a
+ * semicolon (e.g. `&nbsp`, `&amp`, `&copy`), decimal numeric references (e.g.
+ * `&#160`, `&#169`), and hex numeric references (e.g. `&#xa0`, `&#xA0`).
+ * Entities that already include the semicolon are left for the standard parser
+ * to handle.
  */
 
 
@@ -100447,7 +100425,7 @@ const processTableNode = (node, index, parent, documentPosition) => {
         ((candidate.type === 'mdxJsxFlowElement' || candidate.type === 'mdxJsxTextElement') &&
             candidate.name === 'HTMLBlock'), () => {
         tableHasFlowContent = true;
-        return EXIT;
+        return lib_EXIT;
     });
     // Re-parse text-only cells through markdown and detect flow content
     lib_visit(node, isTableCell, (cell) => {
@@ -100661,7 +100639,7 @@ const mdxish_tables_mdxishTables = () => tree => {
                 if (tableNode.name !== 'Table' && tableNode.name !== 'table')
                     return undefined;
                 processTableNode(tableNode, index, parent, node.position);
-                return EXIT;
+                return lib_EXIT;
             });
         }
         else if (node.value.startsWith('<table')) {
@@ -101147,13 +101125,13 @@ const visitor = (table, index, parent) => {
     let hasFlowContent = false;
     const tableCellVisitor = (cell) => {
         if (cell.children.length === 0)
-            return EXIT;
+            return lib_EXIT;
         const content = cell.children.length === 1 && cell.children[0].type === 'paragraph'
             ? cell.children[0].children[0]
             : cell.children[0];
         // If cell is empty there's nothing to visit
         if (!content)
-            return EXIT;
+            return lib_EXIT;
         // @note: Compatibility with RDMD. Ideally, I'd put this in a separate
         // transformer, but then there'd be some duplication.
         lib_visit(cell, 'break', (_, breakIndex, breakParent) => {
@@ -101161,12 +101139,12 @@ const visitor = (table, index, parent) => {
         });
         if (!(lib_phrasing(content) || content.type === 'plain') && content.type !== 'escape') {
             hasFlowContent = true;
-            return EXIT;
+            return lib_EXIT;
         }
         lib_visit(cell, isLiteral, (node) => {
             if (node.value.match(/\n/)) {
                 hasFlowContent = true;
-                return EXIT;
+                return lib_EXIT;
             }
         });
     };
@@ -119381,7 +119359,7 @@ function media(state, node) {
   lib_visit(fragment, function (node) {
     if (node.type === 'link') {
       linkInFallbackContent = true
-      return EXIT
+      return lib_EXIT
     }
   })
 
@@ -120905,7 +120883,7 @@ const trimEmphasis = (node, index, parent) => {
             trimmed = true;
             child.value = newValue;
         }
-        return EXIT;
+        return lib_EXIT;
     });
     lib_visit(node, 'text', (child) => {
         const newValue = child.value.trimEnd();
@@ -120913,7 +120891,7 @@ const trimEmphasis = (node, index, parent) => {
             trimmed = true;
             child.value = newValue;
         }
-        return EXIT;
+        return lib_EXIT;
     }, true);
     if (trimmed) {
         addSpaceBefore(index, parent);
@@ -126500,9 +126478,9 @@ const resolveDeferredAttributeExpressionProps = () => (tree, file) => {
                 properties[name] = name === 'style' && style_object_to_css_isPlainObject(result) ? styleObjectToCssText(result) : result;
             }
             catch {
-                // Evaluation failed — fall back to the raw expression source so the attribute
-                // renders as readable text rather than disappearing.
-                properties[name] = source;
+                // Evaluation failed — keep the literal `{...}`, matching how `evaluateExpressions` falls
+                // back in body text. Variable references like `{user.name}` stay resolvable at render time.
+                properties[name] = `{${source}}`;
             }
         });
         delete node.data.deferredExpressions;
@@ -126593,6 +126571,7 @@ const restoreBooleanProperties = () => tree => {
 
 
 
+
 const SELF_CLOSING_JSX_REGEX = /^\s*<[A-Z][^>]*\/>\s*$/;
 const mdxish_tables_to_jsx_alignToStyle = (align) => {
     if (!align || align === 'left')
@@ -126608,6 +126587,38 @@ const mdxish_tables_to_jsx_alignToStyle = (align) => {
 };
 const mdxish_tables_to_jsx_isTableCell = (node) => ['tableHead', 'tableCell'].includes(node.type);
 const mdxish_tables_to_jsx_isLiteral = (node) => 'value' in node;
+/**
+ * Block-level content that a single-line GFM cell cannot hold. `phrasing()` returns true
+ * for inline types (text, emphasis, strong, link…), which are safe to keep.
+ */
+const isFlowChild = (child) => {
+    if (child.type === 'paragraph' || child.type === 'plain' || child.type === 'escape')
+        return false;
+    if (child.type === NodeTypes.variable)
+        return false;
+    if (phrasing(child))
+        return false;
+    if (child.type === 'html')
+        return SELF_CLOSING_JSX_REGEX.test(child.value);
+    return true;
+};
+/** A newline in a normalized cell (e.g. inside `inlineCode`) has no inline equivalent. */
+const containsLiteralNewline = (nodes) => nodes.some(node => (mdxish_tables_to_jsx_isLiteral(node) && node.value.includes('\n')) || (hasChildren(node) && containsLiteralNewline(node.children)));
+/** True when normalized cell content survives a single-line GFM pipe cell without losing structure. */
+const canCellBeGfm = (children) => {
+    // Multiple paragraphs are distinct blocks; a single-line cell cannot keep them apart.
+    if (children.filter(child => child.type === 'paragraph').length > 1)
+        return false;
+    if (children.some(isFlowChild))
+        return false;
+    return !containsLiteralNewline(children);
+};
+/** On the promote path a `break` would serialize as a dangling `\`, so collapse it to a newline. */
+const flattenBreaksToNewlines = (cell) => {
+    visit(cell, 'break', (_, index, parent) => {
+        parent.children.splice(index, 1, { type: 'text', value: '\n' });
+    });
+};
 /**
  * Mdxish-specific version of `tablesToJsx`. Differs from the shared MDX version:
  *
@@ -126618,52 +126629,25 @@ const mdxish_tables_to_jsx_isLiteral = (node) => 'value' in node;
  */
 const mdxish_tables_to_jsx_mdxishTablesToJsx = () => tree => {
     visit(tree, (node) => ['table', 'tableau'].includes(node.type), (table, index, parent) => {
-        let hasFlowContent = false;
+        const gfmCells = [];
+        let requiresJsxTable = false;
         visit(table, mdxish_tables_to_jsx_isTableCell, (cell) => {
-            if (hasFlowContent || cell.children.length === 0)
-                return;
-            visit(cell, 'break', (_, breakIndex, breakParent) => {
-                breakParent.children.splice(breakIndex, 1, { type: 'text', value: '\n' });
-            });
-            // A cell with more than one paragraph child cannot be serialized as GFM
-            // (pipe tables are single-line per cell), so force JSX <Table> output to
-            // preserve paragraph separation.
-            const paragraphCount = cell.children.filter(child => child.type === 'paragraph').length;
-            if (paragraphCount > 1) {
-                hasFlowContent = true;
-                return;
-            }
-            // Check if any child is "flow" content (block-level) that requires JSX <Table>
-            // serialization instead of GFM. `phrasing()` from mdast-util-phrasing returns
-            // true for inline node types (text, emphasis, strong, link, etc.) which are
-            // safe to keep in GFM cells.
-            const hasFlowChild = cell.children.some(child => {
-                if (child.type === 'paragraph' || child.type === 'plain' || child.type === 'escape')
-                    return false;
-                if (child.type === NodeTypes.variable)
-                    return false;
-                if (phrasing(child))
-                    return false;
-                if (child.type === 'html') {
-                    return SELF_CLOSING_JSX_REGEX.test(child.value);
-                }
-                return true;
-            });
-            if (hasFlowChild) {
-                hasFlowContent = true;
-            }
-            if (!hasFlowContent) {
-                visit(cell, mdxish_tables_to_jsx_isLiteral, (node) => {
-                    if (node.value.match(/\n/)) {
-                        hasFlowContent = true;
-                    }
-                });
+            const normalized = normalizeCellChildrenForGfm(cell);
+            if (!canCellBeGfm(normalized)) {
+                requiresJsxTable = true;
+                return EXIT;
             }
+            gfmCells.push([cell, normalized]);
+            return undefined;
         });
-        if (!hasFlowContent) {
+        if (!requiresJsxTable) {
+            gfmCells.forEach(([cell, children]) => {
+                cell.children = children;
+            });
             table.type = 'table';
             return;
         }
+        visit(table, mdxish_tables_to_jsx_isTableCell, flattenBreaksToNewlines);
         const styles = table.align.map(mdxish_tables_to_jsx_alignToStyle);
         const head = {
             attributes: [],
@@ -127313,6 +127297,24 @@ const Contexts = ({ children, terms = [], variables = { user: {}, defaults: [] }
 };
 /* harmony default export */ const contexts = (Contexts);
 
+;// ./utils/user.ts
+const User = (variables) => {
+    const { user = {}, defaults = [] } = variables || {};
+    return new Proxy(user, {
+        get(target, attribute) {
+            if (typeof attribute === 'symbol') {
+                return '';
+            }
+            if (attribute in target) {
+                return target[attribute];
+            }
+            const def = defaults.find((d) => d.name === attribute);
+            return def ? def.default : attribute.toUpperCase();
+        },
+    });
+};
+/* harmony default export */ const user = (User);
+
 ;// ./lib/utils/makeUseMdxComponents.ts
 
 
@@ -127343,6 +127345,35 @@ const makeUseMDXComponents = (more = {}) => {
 };
 /* harmony default export */ const makeUseMdxComponents = (makeUseMDXComponents);
 
+;// ./lib/utils/mdxish/mdxish-variables.ts
+
+// The `$` guard skips template-literal interpolation: `${user.name}` embeds `{user.name}`, and
+// substituting it would leave a mangled `` `Hi $Name` `` behind. Those belong to an expression,
+// which either evaluated already or is meant to stay literal.
+const MDX_VARIABLE_REGEX = new RegExp(`(?<!\\$)${variable_dist.MDX_VARIABLE_REGEXP}`, 'gu');
+// Bracket notation names the same variable as dot notation, so normalize it before substituting.
+// Escaped and `$`-prefixed forms are left alone so a reference that stays literal keeps its source.
+// A closing escape needs no lookahead: requiring a literal `]}` already rules out `]\}`.
+const BRACKET_NOTATION_REGEX = /(?<![$\\])\{user\[['"](\w+)['"]\]\}/gu;
+/**
+ * Resolve `{user.*}` in a JSX attribute value against the same `user` binding the rmdx engine gets,
+ * so both engines agree. Body text differs on empty values: `Variable` falls back to the default.
+ *
+ * Legacy `<<...>>` is valid inside a quoted attribute but deliberately left literal — attributes are
+ * an MDX surface, and `{user.*}` is the syntax authors use there.
+ */
+function resolveAttributeVariables(value, user) {
+    if (!value.includes('{user'))
+        return value;
+    return value
+        .replace(BRACKET_NOTATION_REGEX, '{user.$1}')
+        .replace(MDX_VARIABLE_REGEX, (source, escapePrefix, name, escapeSuffix) => {
+        if (escapePrefix || escapeSuffix)
+            return source;
+        return user[name];
+    });
+}
+
 ;// ./lib/utils/mdxish/mdxish-render-utils.tsx
 
 
@@ -127351,6 +127382,8 @@ const makeUseMDXComponents = (more = {}) => {
 
 
 
+
+
 /** Flatten CustomComponents into a component map for rehype-react */
 function exportComponentsForRehype(components) {
     const exported = Object.entries(components).reduce((memo, [tag, mod]) => {
@@ -127378,6 +127411,28 @@ function exportComponentsForRehype(components) {
     result.variable = (variable_dist_default());
     return result;
 }
+/**
+ * Code rides on a `value` prop, and `variablesCodeResolver` owns it at parse time where it
+ * deliberately leaves mermaid alone; resolving it again here would override that.
+ */
+const CODE_TAG_NAMES = new Set(['code']);
+/** Raw markup injected with `dangerouslySetInnerHTML` by HTMLBlock and Embed — never interpolate. */
+const RAW_HTML_PROP_NAMES = new Set(['html']);
+/**
+ * Resolve `{user.*}` in string-valued props. Body text is handled by the `Variable` component, but
+ * attributes are plain strings, so they are substituted here — at render time, so that a
+ * server-parsed (user-agnostic) tree resolves against the current reader's variables.
+ */
+function resolveVariablesInProps(props, user, tagName) {
+    const isCodeTag = Boolean(tagName && CODE_TAG_NAMES.has(tagName));
+    const resolvedEntries = Object.entries(props).map(([key, value]) => {
+        const isDocumentContent = RAW_HTML_PROP_NAMES.has(key) || (isCodeTag && key === 'value');
+        if (typeof value !== 'string' || isDocumentContent)
+            return [key, value];
+        return [key, resolveAttributeVariables(value, user)];
+    });
+    return Object.fromEntries(resolvedEntries);
+}
 /**
  * Custom React.createElement wrapper that recovers real JS prop values for
  * custom components. rehype-react v6 uses hast-to-hyperscript, which stringifies
@@ -127389,7 +127444,7 @@ function exportComponentsForRehype(components) {
  * Only arrays win over `rest`, overwriting other shapes would undo correct
  * React conversions like `style="color:red"` → `{ color: 'red' }`.
  */
-function createElementPreservingHastProps(type, props, ...children) {
+const makeCreateElementPreservingHastProps = (user) => function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
         const mergedProps = { ...rest };
@@ -127399,15 +127454,16 @@ function createElementPreservingHastProps(type, props, ...children) {
         });
         // Strip undefined so positional args don't shadow node.properties.children
         const definedChildren = children.filter(c => c !== undefined);
-        return external_react_default().createElement(type, mergedProps, ...definedChildren);
+        const withVariables = resolveVariablesInProps(mergedProps, user, node.tagName);
+        return external_react_default().createElement(type, withVariables, ...definedChildren);
     }
-    return external_react_default().createElement(type, props, ...children);
-}
+    return external_react_default().createElement(type, props && resolveVariablesInProps(props, user), ...children);
+};
 /** Create a rehype-react processor */
-function createRehypeReactProcessor(components) {
+function createRehypeReactProcessor(components, variables) {
     // @ts-expect-error - rehype-react types are incompatible with React.Fragment return type
     return lib_unified().use((rehype_react_default()), {
-        createElement: createElementPreservingHastProps,
+        createElement: makeCreateElementPreservingHastProps(user(variables)),
         Fragment: (external_react_default()).Fragment,
         components,
         passNode: true,
@@ -127422,7 +127478,7 @@ function createTocComponent(tocHast) {
         components: { p: (external_react_default()).Fragment },
     });
     const tocReactElement = tocProcessor.stringify(tocHast);
-    const TocComponent = () => tocReactElement ? (external_react_default().createElement(components_TableOfContents, null, tocReactElement)) : null;
+    const TocComponent = () => tocReactElement ? external_react_default().createElement(components_TableOfContents, null, tocReactElement) : null;
     TocComponent.displayName = 'Toc';
     return TocComponent;
 }
@@ -127471,7 +127527,7 @@ const renderMdxish = (tree, opts = {}) => {
     Object.entries(localScope).forEach(([name, value]) => {
         componentsForRehype[name] = value;
     });
-    const processor = createRehypeReactProcessor(componentsForRehype);
+    const processor = createRehypeReactProcessor(componentsForRehype, variables);
     const content = processor.stringify(tree);
     const tocHast = headings.length > 0 ? tocToHast(headings, variables) : null;
     return buildRMDXModule(content, headings, tocHast, { ...contextOpts, variables });
@@ -127527,24 +127583,6 @@ function runSync(code, options) {
 // EXTERNAL MODULE: ./node_modules/react/jsx-runtime.js
 var jsx_runtime = __webpack_require__(4848);
 var jsx_runtime_namespaceObject = /*#__PURE__*/__webpack_require__.t(jsx_runtime, 2);
-;// ./utils/user.ts
-const User = (variables) => {
-    const { user = {}, defaults = [] } = variables || {};
-    return new Proxy(user, {
-        get(target, attribute) {
-            if (typeof attribute === 'symbol') {
-                return '';
-            }
-            if (attribute in target) {
-                return target[attribute];
-            }
-            const def = defaults.find((d) => d.name === attribute);
-            return def ? def.default : attribute.toUpperCase();
-        },
-    });
-};
-/* harmony default export */ const user = (User);
-
 ;// ./lib/run.tsx