@mulanjs/mulanjs 1.0.1-dev.20260227135307 → 1.0.1-dev.20260227173253

package/dist/compiler/script-compiler.js

@@ -175,118 +175,112 @@ export default ${hasDefineComponent ? 'defineComponent' : '_defineComponent'}({
 });
     `;
     const finalCode = preamble + scriptBody + postamble;
-    if (isTs) {
-        // Transpile extracted TS code to JS
-        const result = ts.transpileModule(finalCode, {
-            compilerOptions: {
-                module: ts.ModuleKind.ESNext,
-                target: ts.ScriptTarget.ES2019,
-                sourceMap: true, // ENABLE SOURCE MAPS
-                inlineSources: true,
-                sourceRoot: '/',
-            },
-            fileName: filename // We ask TS to map to filename, but it maps 'finalCode' -> 'filename'
-        });
-        // Fix: Remove the //# sourceMappingURL= comment added by TS
-        const codeWithoutMapComment = result.outputText.replace(/\/\/# sourceMappingURL=.*$/gm, '');
-        // Enhance Source Map to show ORIGINAL .mujs content or EXTERNAL content
-        let finalMap = result.sourceMapText;
-        if (finalMap) {
-            try {
-                // Determine offsets
-                const preambleLines = preamble.split('\n').length - 1;
-                // scriptBody starts at line `preambleLines` (0-indexed) in finalCode.
-                // Determine where script starts
-                // If External: Start at 0
-                // If Inline: Start at script.start line
-                let linesBeforeScript = 0;
-                let originalSource = content;
-                if (!isExternal) {
-                    originalSource = descriptor.source;
-                    linesBeforeScript = originalSource.substring(0, script.start).split('\n').length - 1;
-                }
-                const consumer = new source_map_1.SourceMapConsumer(JSON.parse(finalMap));
-                const generator = new source_map_1.SourceMapGenerator({
-                    file: filename,
-                    sourceRoot: ''
-                });
-                // Determine relative path for source
-                let relativePath = filename.split(/[/\\]/).pop() || 'unknown.mujs'; // Default to basename
-                if (isExternal) {
-                    // For external files, we want Source Map to point to the actual TS file
-                    // externalPath is absolute. Make it relative to project root or something reasonable?
-                    // Webpack often likes 'webpack:///[resource-path]'
-                    // We'll try to map it so it looks like a separate file
-                    const normalized = externalPath.replace(/\\/g, '/');
-                    const srcIdx = normalized.indexOf('/src/');
-                    if (srcIdx !== -1) {
-                        relativePath = 'webpack:///' + normalized.substring(srcIdx + 1); // e.g. webpack:///src/logic.ts
-                    }
-                    else {
-                        relativePath = 'webpack:///' + path.basename(externalPath);
-                    }
+    // Standardize to CommonJS for SSR/Node compatibility
+    // Transpile extracted code to JS (handles TS and ESM -> CJS)
+    const result = ts.transpileModule(finalCode, {
+        compilerOptions: {
+            module: ts.ModuleKind.CommonJS,
+            target: ts.ScriptTarget.ES2019,
+            sourceMap: true,
+            inlineSources: true,
+            sourceRoot: '/',
+        },
+        fileName: filename
+    });
+    const codeWithoutMapComment = result.outputText.replace(/\/\/# sourceMappingURL=.*$/gm, '');
+    let finalMap = result.sourceMapText;
+    if (isTs && finalMap) {
+        // ... (source map logic)
+    }
+    if (finalMap) {
+        try {
+            // Determine offsets
+            const preambleLines = preamble.split('\n').length - 1;
+            // scriptBody starts at line `preambleLines` (0-indexed) in finalCode.
+            // Determine where script starts
+            // If External: Start at 0
+            // If Inline: Start at script.start line
+            let linesBeforeScript = 0;
+            let originalSource = content;
+            if (!isExternal) {
+                originalSource = descriptor.source;
+                linesBeforeScript = originalSource.substring(0, script.start).split('\n').length - 1;
+            }
+            const consumer = new source_map_1.SourceMapConsumer(JSON.parse(finalMap));
+            const generator = new source_map_1.SourceMapGenerator({
+                file: filename,
+                sourceRoot: ''
+            });
+            // Determine relative path for source
+            let relativePath = filename.split(/[/\\]/).pop() || 'unknown.mujs'; // Default to basename
+            if (isExternal) {
+                // For external files, we want Source Map to point to the actual TS file
+                // externalPath is absolute. Make it relative to project root or something reasonable?
+                // Webpack often likes 'webpack:///[resource-path]'
+                // We'll try to map it so it looks like a separate file
+                const normalized = externalPath.replace(/\\/g, '/');
+                const srcIdx = normalized.indexOf('/src/');
+                if (srcIdx !== -1) {
+                    relativePath = 'webpack:///' + normalized.substring(srcIdx + 1); // e.g. webpack:///src/logic.ts
                 }
                 else {
-                    // Inline: Point to .mujs file
-                    const normalized = filename.replace(/\\/g, '/');
-                    const srcIdx = normalized.indexOf('/src/');
-                    if (srcIdx !== -1) {
-                        relativePath = 'webpack:///' + normalized.substring(srcIdx + 1); // e.g. webpack:///src/App.mujs
-                    }
+                    relativePath = 'webpack:///' + path.basename(externalPath);
                 }
-                // If inline, we set source content of .mujs (the whole file)
-                // If external, we set source content of the .ts file
-                generator.setSourceContent(relativePath, originalSource);
-                consumer.eachMapping((m) => {
-                    if (m.originalLine === null)
-                        return;
-                    // m.originalLine is the line in `finalCode` (1-based because SourceMapConsumer uses 1-based)
-                    // We need to convert it to line in `.mujs`.
-                    // Check if this line belongs to scriptBody
-                    // scriptBody spans from (preambleLines + 1) to (preambleLines + scriptBodyLines)
-                    const lineInFinalCode = m.originalLine;
-                    // Check if strictly inside body
-                    if (lineInFinalCode > preambleLines) {
-                        // Calculate offset inside scriptBody
-                        const lineOffsetInBody = lineInFinalCode - preambleLines; // 1-based offset (1st line of body is 1)
-                        // Calculate original line
-                        // If External: lineOffsetInBody is the line number
-                        // If Inline: linesBeforeScript + lineOffsetInBody
-                        const originalLine = linesBeforeScript + lineOffsetInBody;
-                        // Add mapping
-                        generator.addMapping({
-                            generated: {
-                                line: m.generatedLine,
-                                column: m.generatedColumn
-                            },
-                            original: {
-                                line: originalLine,
-                                column: m.originalColumn // Column should be preserved if we didn't change indentation
-                            },
-                            source: relativePath,
-                            name: m.name
-                        });
-                    }
-                });
-                finalMap = generator.toString();
-                // consumer.destroy() not needed in 0.6.x
             }
-            catch (e) {
-                console.warn('[MulanJS] Failed to patch source map:', e);
+            else {
+                // Inline: Point to .mujs file
+                const normalized = filename.replace(/\\/g, '/');
+                const srcIdx = normalized.indexOf('/src/');
+                if (srcIdx !== -1) {
+                    relativePath = 'webpack:///' + normalized.substring(srcIdx + 1); // e.g. webpack:///src/App.mujs
+                }
             }
+            // If inline, we set source content of .mujs (the whole file)
+            // If external, we set source content of the .ts file
+            generator.setSourceContent(relativePath, originalSource);
+            consumer.eachMapping((m) => {
+                if (m.originalLine === null)
+                    return;
+                // m.originalLine is the line in `finalCode` (1-based because SourceMapConsumer uses 1-based)
+                // We need to convert it to line in `.mujs`.
+                // Check if this line belongs to scriptBody
+                // scriptBody spans from (preambleLines + 1) to (preambleLines + scriptBodyLines)
+                const lineInFinalCode = m.originalLine;
+                // Check if strictly inside body
+                if (lineInFinalCode > preambleLines) {
+                    // Calculate offset inside scriptBody
+                    const lineOffsetInBody = lineInFinalCode - preambleLines; // 1-based offset (1st line of body is 1)
+                    // Calculate original line
+                    // If External: lineOffsetInBody is the line number
+                    // If Inline: linesBeforeScript + lineOffsetInBody
+                    const originalLine = linesBeforeScript + lineOffsetInBody;
+                    // Add mapping
+                    generator.addMapping({
+                        generated: {
+                            line: m.generatedLine,
+                            column: m.generatedColumn
+                        },
+                        original: {
+                            line: originalLine,
+                            column: m.originalColumn // Column should be preserved if we didn't change indentation
+                        },
+                        source: relativePath,
+                        name: m.name
+                    });
+                }
+            });
+            finalMap = generator.toString();
+            // consumer.destroy() not needed in 0.6.x
+        }
+        catch (e) {
+            console.warn('[MulanJS] Failed to patch source map:', e);
         }
-        return {
-            code: codeWithoutMapComment,
-            bindings,
-            errors: [],
-            map: finalMap // Return the enhanced map
-        };
     }
     return {
-        code: finalCode,
+        code: codeWithoutMapComment,
         bindings,
         errors: [],
-        map: undefined
+        map: finalMap // Return the enhanced map
     };
 }
 async function compileStandardScript(script, descriptor, content, filename, isExternal, externalPath) {
@@ -294,20 +288,18 @@ async function compileStandardScript(script, descriptor, content, filename, isEx
     // and/or just to map it back to .mujs
     let finalMap;
     let code = content;
-    // Transpile if TS
-    if (externalPath.endsWith('.ts') || script.attrs.lang === 'ts') {
-        const result = ts.transpileModule(content, {
-            compilerOptions: {
-                module: ts.ModuleKind.ESNext,
-                target: ts.ScriptTarget.ES2019,
-                sourceMap: true,
-                inlineSources: true,
-            },
-            fileName: filename
-        });
-        code = result.outputText.replace(/\/\/# sourceMappingURL=.*$/gm, '');
-        finalMap = result.sourceMapText;
-    }
+    // Standardize to CommonJS for SSR/Node compatibility
+    const result = ts.transpileModule(content, {
+        compilerOptions: {
+            module: ts.ModuleKind.CommonJS,
+            target: ts.ScriptTarget.ES2019,
+            sourceMap: true,
+            inlineSources: true,
+        },
+        fileName: filename
+    });
+    code = result.outputText.replace(/\/\/# sourceMappingURL=.*$/gm, '');
+    finalMap = result.sourceMapText;
     // Adjust Source Map
     if (finalMap) {
         try {

package/dist/compiler/sfc-parser.d.ts

@@ -0,0 +1,21 @@
+export interface SFCBlock {
+    type: 'script' | 'template' | 'style';
+    content: string;
+    attrs: Record<string, string>;
+    start: number;
+    end: number;
+}
+export interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCBlock | null;
+    script: SFCBlock | null;
+    scripts: SFCBlock[];
+    styles: SFCBlock[];
+    customBlocks: SFCBlock[];
+}
+/**
+ * Standardized State-Machine Parser for MulanJS
+ * Parses .mujs files safely, handling attributes, quotes, and nested content.
+ */
+export declare function parseMUJS(source: string, filename: string): SFCDescriptor;

package/dist/compiler/ssr-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+import { ScriptCompileResult } from './script-compiler';
+export interface SSRCompileResult {
+    code: string;
+    errors: string[];
+}
+export declare function compileToSSR(descriptor: SFCDescriptor, scriptResult: ScriptCompileResult, scopedId?: string): SSRCompileResult;

package/dist/compiler/ssr-compiler.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileToSSR = void 0;
+const ast_parser_1 = require("./ast-parser");
+function compileToSSR(descriptor, scriptResult, scopedId) {
+    const template = descriptor.template;
+    if (!template)
+        return { code: 'function render() { return ""; }', errors: [] };
+    const errors = [];
+    const ast = (0, ast_parser_1.parse)(template.content, errors);
+    // Simplistic Transformer (Options API bindings mapping)
+    const bindings = scriptResult.bindings || [];
+    const localScope = [];
+    let uidRef = { current: 0 };
+    const getUid = () => uidRef.current++;
+    let codeChunks = [];
+    ast.children.forEach(child => {
+        const chunk = generateSSRInstruction(child, bindings, localScope, getUid);
+        if (chunk)
+            codeChunks.push(chunk);
+    });
+    // The render function generates a giant template literal
+    const bodyFn = `return \`${codeChunks.join('')}\`;`;
+    const renderFn = `function render() { 
+            const _s = (v) => (v && typeof v === 'object' && 'value' in v) ? v.value : (v === null || v === undefined ? '' : v);
+            const _h = (v) => {
+                const val = _s(v);
+                if (val === null || val === undefined) return '';
+                if (typeof val !== 'string') return val;
+                if (typeof Mulan !== 'undefined' && Mulan.Security) {
+                    return Mulan.Security.sanitize(val);
+                }
+                return val.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#039;');
+            };
+            
+            ${bodyFn}
+        }`;
+    return {
+        code: renderFn,
+        errors
+    };
+}
+exports.compileToSSR = compileToSSR;
+function processBindings(exp, bindings, localScope) {
+    const isOptionsAPI = !bindings || bindings.length === 0;
+    const bindingSet = new Set(bindings || []);
+    return exp.replace(/\b([a-zA-Z_$][\w$]*)\b/g, (match, id, offset, str) => {
+        if (offset > 0 && str[offset - 1] === '.')
+            return match;
+        // simplistic keyword check
+        if (['true', 'false', 'null', 'undefined', 'this', 'Math'].includes(id) || localScope.includes(id))
+            return match;
+        if (isOptionsAPI)
+            return `this.${id}`;
+        if (bindingSet.has(id))
+            return `this.${id}`;
+        return match;
+    });
+}
+function generateSSRInstruction(node, bindings, localScope, getUid) {
+    if (node.type === 'Text') {
+        const text = node;
+        // we can preserve interpolation \${ } because the outer string is also a template literal
+        // but we need to ensure the variables map to 'this'
+        if (text.content.includes('${')) {
+            let processed = text.content.replace(/\$\{(.*?)\}/g, (_, expr) => {
+                return `\${_h(${processBindings(expr, bindings, localScope)})}`;
+            });
+            return processed;
+        }
+        return text.content;
+    }
+    if (node.type === 'Interpolation') {
+        const interp = node;
+        return `\${_h(${processBindings(interp.content, bindings, localScope)})}`;
+    }
+    if (node.type === 'Element') {
+        const el = node;
+        const uid = getUid();
+        let html = `<${el.tag} data-mu-node-id="${uid}"`;
+        let vIfCondition = '';
+        let vForDirective = null;
+        for (const key in el.props) {
+            if (key === 'v-if' || key === 'mu-if') {
+                vIfCondition = processBindings(el.props[key], bindings, localScope);
+                continue;
+            }
+            if (key === 'v-for' || key === 'mu-for') {
+                const parts = el.props[key].split(' in ');
+                if (parts.length >= 2) {
+                    vForDirective = { item: parts[0].trim(), list: processBindings(parts.slice(1).join(' in ').trim(), bindings, localScope) };
+                }
+                continue;
+            }
+            // Client side events are ignored in SSR HTML output
+            if (key.startsWith('@') || key.startsWith('v-on:') || key.startsWith('on')) {
+                // To support Resumability, we'd inject a serialize marker here
+                // html += ` mu-event="${key}"`; 
+                continue;
+            }
+            let value = el.props[key];
+            if (key.startsWith(':') || key.startsWith('.')) {
+                let attrName = key.slice(1);
+                let expr = processBindings(value, bindings, localScope);
+                html += ` ${attrName}="\${_h(${expr})}"`;
+            }
+            else {
+                if (value.includes('${')) {
+                    value = value.replace(/\$\{(.*?)\}/g, (_, expr) => {
+                        return `\${_h(${processBindings(expr, bindings, localScope)})}`;
+                    });
+                    html += ` ${key}="${value}"`;
+                }
+                else {
+                    html += ` ${key}="${value.replace(/"/g, '&quot;')}"`;
+                }
+            }
+        }
+        const isSelfClosing = ['img', 'br', 'input', 'hr', 'link', 'meta'].includes(el.tag.toLowerCase());
+        if (isSelfClosing) {
+            html += '/>';
+        }
+        else {
+            html += '>';
+            for (const child of el.children) {
+                html += generateSSRInstruction(child, bindings, localScope, getUid);
+            }
+            html += `</${el.tag}>`;
+        }
+        // Apply wrappers for Control Flow (v-if / v-for)
+        if (vIfCondition) {
+            html = `\${(${vIfCondition}) ? \`${html}\` : '<!--mu-if-->'}`;
+        }
+        if (vForDirective) {
+            const { item, list } = vForDirective;
+            // The mapping function returns strings which we join
+            html = `\${(${list}).map((${item}, _index) => \`${html}\`).join('')}`;
+        }
+        return html;
+    }
+    return '';
+}

package/dist/compiler/style-compiler.d.ts

@@ -0,0 +1,8 @@
+import { SFCDescriptor } from './sfc-parser';
+import { CompilerOptions } from './script-compiler';
+export interface StyleCompileResult {
+    css: string;
+    scopedId?: string;
+    errors: string[];
+}
+export declare function compileStyle(descriptor: SFCDescriptor, filename: string, options?: CompilerOptions): StyleCompileResult;

package/dist/compiler/template-compiler.d.ts

@@ -0,0 +1,8 @@
+import { SFCDescriptor } from './sfc-parser';
+import { ScriptCompileResult } from './script-compiler';
+export interface TemplateCompileResult {
+    code: string;
+    errors: string[];
+    map?: string;
+}
+export declare function compileTemplate(descriptor: SFCDescriptor, scriptResult: ScriptCompileResult, scopedId?: string): TemplateCompileResult;

package/dist/components/bloch-sphere.js

@@ -1,5 +1,10 @@
-import { effect } from '../core/reactive';
-export class MuBlochSphereElement extends HTMLElement {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MuBlochSphereElement = void 0;
+const reactive_1 = require("../core/reactive");
+const MuBlochBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuBlochSphereElement extends MuBlochBase {
     static get observedAttributes() {
         return ['size'];
     }
@@ -39,7 +44,7 @@ export class MuBlochSphereElement extends HTMLElement {
         if (!this._qubit)
             return;
         // MulanJS Effect: Run whenever the qubit state changes
-        this._disposeEffect = effect(() => {
+        this._disposeEffect = (0, reactive_1.effect)(() => {
             const state = this._qubit.value; // Access reactive proxy
             if (!state || !state.amplitudes)
                 return;
@@ -246,6 +251,7 @@ export class MuBlochSphereElement extends HTMLElement {
             this.initReactivity();
     }
 }
+exports.MuBlochSphereElement = MuBlochSphereElement;
 // Register the custom element
 if (typeof customElements !== 'undefined') {
     customElements.define('mu-bloch-sphere', MuBlochSphereElement);

package/dist/components/infinity-list.js

@@ -1,4 +1,9 @@
-export class MuInfinity extends HTMLElement {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MuInfinity = void 0;
+const MuInfinityBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuInfinity extends MuInfinityBase {
     constructor() {
         super();
         this._items = [];
@@ -104,6 +109,7 @@ export class MuInfinity extends HTMLElement {
         this.content.innerHTML = html;
     }
 }
+exports.MuInfinity = MuInfinity;
 // Register
 if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
     customElements.define('mu-infinity', MuInfinity);

package/dist/core/component.js

@@ -1,14 +1,19 @@
-import { render } from './renderer';
-import { setCurrentInstance } from './hooks';
-import { effect } from './reactive';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineComponent = exports.MuComponent = void 0;
+const renderer_1 = require("./renderer");
+const hooks_1 = require("./hooks");
+const reactive_1 = require("./reactive");
 // Or a simple component that returns an object of state/methods used by template? 
 // For Mulan 2.0, let's say functional component returns a template string render function explicitly.
-export class MuComponent {
+class MuComponent {
     constructor(container) {
         this._hooks = {};
         this._effects = [];
         this._domEffects = [];
         this._isDestroyed = false;
+        this._isResuming = false; // Quantum Resumability Flag
+        this._resumeRoot = null;
         this._propsQueue = [];
         this._eventQueue = [];
         // --- MulanJS List Reconciliation Engine (No-VDOM) ---
@@ -20,6 +25,26 @@ export class MuComponent {
         this.container = container;
         this.state = {};
         this.$uid = 'mu_' + Math.random().toString(36).substr(2, 9);
+        // MULAN INSIGHT: Quantum Resumability Detection
+        if (typeof window !== 'undefined' && container) {
+            const rootAttr = container.getAttribute('data-mu-root');
+            const stateScript = container.querySelector('script[type="mulan/state"]');
+            if (rootAttr || stateScript) {
+                console.log(`%c[Mulan Quantum]%c Resuming component from server state...`, "color: #00ffcc; font-weight: bold;", "");
+                this._isResuming = true;
+                this.$uid = rootAttr || this.$uid;
+                if (stateScript) {
+                    try {
+                        const serverState = JSON.parse(stateScript.textContent || '{}');
+                        // Inject server state into this instance
+                        Object.assign(this, serverState);
+                    }
+                    catch (e) {
+                        console.error("[Mulan Quantum] Failed to parse server state:", e);
+                    }
+                }
+            }
+        }
         // MULAN INSIGHT: Global Registry for Debugging
         if (typeof window !== 'undefined') {
             const global = window;
@@ -27,9 +52,9 @@ export class MuComponent {
             global.__MULAN_INSIGHT__.components.set(this.$uid, this);
         }
         // Setup context for hooks
-        setCurrentInstance(this);
+        (0, hooks_1.setCurrentInstance)(this);
         this.setup();
-        setCurrentInstance(null);
+        (0, hooks_1.setCurrentInstance)(null);
     }
     // Optional setup method for class components wanting to use hooks
     setup() { }
@@ -80,17 +105,41 @@ export class MuComponent {
     }
     mount() {
         console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);
-        // The main render effect (legacy strings fallback / macro structure)
-        const stop = effect(() => {
-            console.log(`[Mulan Reactivity] Triggering macro-update for ${this.$uid}`);
-            this.update();
-        });
-        this._effects.push(stop);
+        if (this._isResuming) {
+            // Quantum Resumability: Skip initial render, just attach effects to existing DOM
+            console.log(`[Mulan Quantum] Skipping initial render, recovering DOM nodes...`);
+            this._resume();
+        }
+        else {
+            // Standard Hydration/Mount
+            const stop = (0, reactive_1.effect)(() => {
+                console.log(`[Mulan Reactivity] Triggering macro-update for ${this.$uid}`);
+                this.update();
+            });
+            this._effects.push(stop);
+        }
         this.onMount();
     }
+    /**
+     * Internal method to execute the resumability pass.
+     * Overridden by compiler-generated code.
+     */
+    _resume() {
+        // Clear queues
+        this._propsQueue = [];
+        this._eventQueue = [];
+        // Call the template with resumption context
+        // In a real implementation, the compiler will inject 'recovery' instructions
+        this._recoveryMode = true;
+        this.template();
+        this._recoveryMode = false;
+        // Flush bindings (events/props) to existing nodes
+        this.flushProps();
+        this.flushEvents();
+    }
     // New helper for the compiler to register a fine-grained DOM property effect
     _bindEffect(fn, targetNode) {
-        const stop = effect(fn, targetNode);
+        const stop = (0, reactive_1.effect)(fn, targetNode);
         this._domEffects.push(stop);
         return stop;
     }
@@ -104,7 +153,7 @@ export class MuComponent {
         this._eventQueue = [];
         const template = this.template();
         // Render HTML
-        render(template, this.container);
+        (0, renderer_1.render)(template, this.container);
         // Flush Side Effects
         this.flushProps();
         this.flushEvents();
@@ -272,10 +321,11 @@ export class MuComponent {
         }
     }
 }
+exports.MuComponent = MuComponent;
 // Helper to create functional components wrapped in the class system
 // Helper to create functional components wrapped in the class system
 // Supports both () => render and { setup() } signatures
-export function defineComponent(optionsOrSetup) {
+function defineComponent(optionsOrSetup) {
     return class UniversalComponent extends MuComponent {
         constructor(container) {
             super(container);
@@ -307,3 +357,4 @@ export function defineComponent(optionsOrSetup) {
         }
     };
 }
+exports.defineComponent = defineComponent;