solid-refresh 0.6.3 → 0.7.0

package/dist/babel.cjs

@@ -2,8 +2,8 @@
 
 var path = require('path');
 var t = require('@babel/types');
-var _generator = require('@babel/generator');
 var helperModuleImports = require('@babel/helper-module-imports');
+var _generator = require('@babel/generator');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -211,79 +211,244 @@ function xxHash32(buffer, seed = 0) {
     return acc < 0 ? acc + 4294967296 : acc;
 }
 
-// https://github.com/babel/babel/issues/15269
-let generator;
-if (typeof _generator !== 'function') {
-    generator = _generator.default;
-}
-else {
-    generator = _generator;
-}
-const CWD = process.cwd();
-function getFile(filename) {
-    return path.relative(CWD, filename);
-}
 // This is just a Pascal heuristic
 // we only assume a function is a component
 // if the first character is in uppercase
 function isComponentishName(name) {
     return name[0] >= 'A' && name[0] <= 'Z';
 }
-function isESMHMR(bundler) {
-    // The currently known ESM HMR implementations
-    // esm - the original ESM HMR Spec
-    // vite - Vite's implementation
-    return bundler === 'esm' || bundler === 'vite';
+function getImportSpecifierName(specifier) {
+    if (t__namespace.isIdentifier(specifier.imported)) {
+        return specifier.imported.name;
+    }
+    return specifier.imported.value;
 }
-// Source of solid-refresh (for import)
-const SOLID_REFRESH_MODULE = 'solid-refresh';
-// Exported names from solid-refresh that will be imported
-const IMPORTS = {
-    registry: '$$registry',
-    refresh: '$$refresh',
-    component: '$$component',
-    context: '$$context',
-    decline: '$$decline',
-};
-function getSolidRefreshIdentifier(state, path, name) {
-    const target = `${name}`;
-    const current = state.hooks.get(target);
-    if (current) {
-        return current;
+
+function registerImportSpecifier(state, id, specifier) {
+    if (t__namespace.isImportDefaultSpecifier(specifier)) {
+        if (id.definition.kind === 'default') {
+            state.registrations.identifiers.set(specifier.local, id);
+        }
+        return;
     }
-    const newID = helperModuleImports.addNamed(path, name, SOLID_REFRESH_MODULE);
-    state.hooks.set(target, newID);
-    return newID;
+    if (t__namespace.isImportSpecifier(specifier)) {
+        if ((id.definition.kind === 'named' &&
+            getImportSpecifierName(specifier) === id.definition.name) ||
+            (id.definition.kind === 'default' &&
+                getImportSpecifierName(specifier) === 'default')) {
+            state.registrations.identifiers.set(specifier.local, id);
+        }
+        return;
+    }
+    let current = state.registrations.namespaces.get(specifier.local);
+    if (!current) {
+        current = [];
+    }
+    current.push(id);
+    state.registrations.namespaces.set(specifier.local, current);
 }
+function registerImportSpecifiers(state, path, definitions) {
+    for (let i = 0, len = definitions.length; i < len; i++) {
+        const id = definitions[i];
+        if (path.node.source.value === id.definition.source) {
+            for (let k = 0, klen = path.node.specifiers.length; k < klen; k++) {
+                registerImportSpecifier(state, id, path.node.specifiers[k]);
+            }
+        }
+    }
+}
+
 function getHotIdentifier(state) {
-    const bundler = state.opts.bundler;
-    // vite/esm uses `import.meta.hot`
-    if (isESMHMR(bundler)) {
-        return t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier('import'), t__namespace.identifier('meta')), t__namespace.identifier('hot'));
+    switch (state.bundler) {
+        // vite/esm uses `import.meta.hot`
+        case 'esm':
+        case 'vite':
+            return t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier('import'), t__namespace.identifier('meta')), t__namespace.identifier('hot'));
+        // webpack 5 uses `import.meta.webpackHot`
+        // rspack does as well
+        case 'webpack5':
+        case 'rspack-esm':
+            return t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier('import'), t__namespace.identifier('meta')), t__namespace.identifier('webpackHot'));
+        default:
+            // `module.hot` is the default.
+            return t__namespace.memberExpression(t__namespace.identifier('module'), t__namespace.identifier('hot'));
     }
-    // webpack 5 uses `import.meta.webpackHot`
-    // rspack does as well
-    if (bundler === 'webpack5' || bundler === 'rspack-esm') {
-        return t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier('import'), t__namespace.identifier('meta')), t__namespace.identifier('webpackHot'));
+}
+
+function getImportIdentifier(state, path, registration) {
+    const name = registration.kind === 'named' ? registration.name : 'default';
+    const target = `${registration.source}[${name}]`;
+    const current = state.imports.get(target);
+    if (current) {
+        return current;
     }
-    // `module.hot` is the default.
-    return t__namespace.memberExpression(t__namespace.identifier('module'), t__namespace.identifier('hot'));
+    const newID = registration.kind === 'named'
+        ? helperModuleImports.addNamed(path, registration.name, registration.source)
+        : helperModuleImports.addDefault(path, registration.source);
+    state.imports.set(target, newID);
+    return newID;
 }
-function generateViteRequirement(state, statements, pathToHot) {
-    if (state.opts.bundler === 'vite') {
+
+// Source of solid-refresh (for import)
+const SOLID_REFRESH_MODULE = 'solid-refresh';
+// Exported names from solid-refresh that will be imported
+const IMPORT_REGISTRY = {
+    kind: 'named',
+    name: '$$registry',
+    source: SOLID_REFRESH_MODULE,
+};
+const IMPORT_REFRESH = {
+    kind: 'named',
+    name: '$$refresh',
+    source: SOLID_REFRESH_MODULE,
+};
+const IMPORT_COMPONENT = {
+    kind: 'named',
+    name: '$$component',
+    source: SOLID_REFRESH_MODULE,
+};
+const IMPORT_CONTEXT = {
+    kind: 'named',
+    name: '$$context',
+    source: SOLID_REFRESH_MODULE,
+};
+const IMPORT_DECLINE = {
+    kind: 'named',
+    name: '$$decline',
+    source: SOLID_REFRESH_MODULE,
+};
+const IMPORT_SPECIFIERS = [
+    {
+        type: 'render',
+        definition: { name: 'render', kind: 'named', source: 'solid-js/web' },
+    },
+    {
+        type: 'render',
+        definition: { name: 'hydrate', kind: 'named', source: 'solid-js/web' },
+    },
+    {
+        type: 'createContext',
+        definition: {
+            name: 'createContext',
+            kind: 'named',
+            source: 'solid-js',
+        },
+    },
+    {
+        type: 'createContext',
+        definition: {
+            name: 'createContext',
+            kind: 'named',
+            source: 'solid-js/web',
+        },
+    },
+];
+
+function generateViteHMRRequirement(state, statements, pathToHot) {
+    if (state.bundler === 'vite') {
         // Vite requires that the owner module has an `import.meta.hot.accept()` call
         statements.push(t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.memberExpression(pathToHot, t__namespace.identifier('accept')), [])));
     }
 }
+
 function getHMRDeclineCall(state, path) {
-    var _a;
     const pathToHot = getHotIdentifier(state);
     const statements = [
-        t__namespace.expressionStatement(t__namespace.callExpression(getSolidRefreshIdentifier(state, path, IMPORTS.decline), [t__namespace.stringLiteral((_a = state.opts.bundler) !== null && _a !== void 0 ? _a : 'standard'), pathToHot])),
+        t__namespace.expressionStatement(t__namespace.callExpression(getImportIdentifier(state, path, IMPORT_DECLINE), [
+            t__namespace.stringLiteral(state.bundler),
+            pathToHot,
+        ])),
     ];
-    generateViteRequirement(state, statements, pathToHot);
+    generateViteHMRRequirement(state, statements, pathToHot);
     return t__namespace.ifStatement(pathToHot, t__namespace.blockStatement(statements));
 }
+
+function isPathValid(path, key) {
+    return key(path.node);
+}
+function isNestedExpression(node) {
+    switch (node.type) {
+        case 'ParenthesizedExpression':
+        case 'TypeCastExpression':
+        case 'TSAsExpression':
+        case 'TSSatisfiesExpression':
+        case 'TSNonNullExpression':
+        case 'TSTypeAssertion':
+        case 'TSInstantiationExpression':
+            return true;
+        default:
+            return false;
+    }
+}
+function unwrapNode(node, key) {
+    if (key(node)) {
+        return node;
+    }
+    if (isNestedExpression(node)) {
+        return unwrapNode(node.expression, key);
+    }
+    return undefined;
+}
+
+function isIdentifierValidCallee(state, path, callee, target) {
+    const binding = path.scope.getBindingIdentifier(callee.name);
+    if (binding) {
+        const result = state.registrations.identifiers.get(binding);
+        if (result && result.type === target) {
+            return true;
+        }
+    }
+    return false;
+}
+function isPropertyValidCallee(result, target, propName) {
+    for (let i = 0, len = result.length; i < len; i++) {
+        const registration = result[i];
+        if (registration.type === target) {
+            if (registration.definition.kind === 'named') {
+                if (registration.definition.name === propName) {
+                    return true;
+                }
+            }
+            else if (propName === 'default') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isMemberExpressionValidCallee(state, path, member, target) {
+    if (!t__namespace.isIdentifier(member.property)) {
+        return false;
+    }
+    const trueObject = unwrapNode(member.object, t__namespace.isIdentifier);
+    if (!trueObject) {
+        return false;
+    }
+    const binding = path.scope.getBindingIdentifier(trueObject.name);
+    if (!binding) {
+        return false;
+    }
+    const result = state.registrations.namespaces.get(binding);
+    if (!result) {
+        return false;
+    }
+    return isPropertyValidCallee(result, target, member.property.name);
+}
+function isValidCallee(state, path, { callee }, target) {
+    if (t__namespace.isV8IntrinsicIdentifier(callee)) {
+        return false;
+    }
+    const trueCallee = unwrapNode(callee, t__namespace.isIdentifier);
+    if (trueCallee) {
+        return isIdentifierValidCallee(state, path, trueCallee, target);
+    }
+    const trueMember = unwrapNode(callee, t__namespace.isMemberExpression);
+    if (trueMember && !trueMember.computed) {
+        return isMemberExpressionValidCallee(state, path, trueMember, target);
+    }
+    return false;
+}
+
 function getStatementPath(path) {
     if (t__namespace.isStatement(path.node)) {
         return path;
@@ -293,40 +458,46 @@ function getStatementPath(path) {
     }
     return null;
 }
+
+function getRootStatementPath(path) {
+    let current = path.parentPath;
+    while (current) {
+        const next = current.parentPath;
+        if (next && t__namespace.isProgram(next.node)) {
+            return current;
+        }
+        current = next;
+    }
+    return path;
+}
+
 const REGISTRY = 'REGISTRY';
 function createRegistry(state, path) {
-    var _a;
-    const current = state.hooks.get(REGISTRY);
+    const current = state.imports.get(REGISTRY);
     if (current) {
         return current;
     }
-    const program = path.scope.getProgramParent();
-    const identifier = program.generateUidIdentifier(REGISTRY);
-    program.push({
-        id: identifier,
-        kind: 'const',
-        init: t__namespace.callExpression(getSolidRefreshIdentifier(state, path, IMPORTS.registry), []),
-    });
+    const root = getRootStatementPath(path);
+    const identifier = path.scope.generateUidIdentifier(REGISTRY);
+    root.insertBefore(t__namespace.variableDeclaration('const', [
+        t__namespace.variableDeclarator(identifier, t__namespace.callExpression(getImportIdentifier(state, path, IMPORT_REGISTRY), [])),
+    ]));
     const pathToHot = getHotIdentifier(state);
     const statements = [
-        t__namespace.expressionStatement(t__namespace.callExpression(getSolidRefreshIdentifier(state, path, IMPORTS.refresh), [
-            t__namespace.stringLiteral((_a = state.opts.bundler) !== null && _a !== void 0 ? _a : 'standard'),
+        t__namespace.expressionStatement(t__namespace.callExpression(getImportIdentifier(state, path, IMPORT_REFRESH), [
+            t__namespace.stringLiteral(state.bundler),
             pathToHot,
             identifier,
         ])),
     ];
-    generateViteRequirement(state, statements, pathToHot);
-    program.path.pushContainer('body', [
+    generateViteHMRRequirement(state, statements, pathToHot);
+    path.scope.getProgramParent().path.pushContainer('body', [
         t__namespace.ifStatement(pathToHot, t__namespace.blockStatement(statements)),
     ]);
-    state.hooks.set(REGISTRY, identifier);
+    state.imports.set(REGISTRY, identifier);
     return identifier;
 }
-function createSignatureValue(node) {
-    const code = generator(node);
-    const result = xxHash32(code.code).toString(16);
-    return result;
-}
+
 function isForeignBinding(source, current, name) {
     if (source === current) {
         return true;
@@ -349,13 +520,15 @@ function isInTypescript(path) {
     }
     return false;
 }
-function getBindings(path) {
+function getForeignBindings(path) {
     const identifiers = new Set();
     path.traverse({
         ReferencedIdentifier(p) {
             // Check identifiers that aren't in a TS expression
             if (!isInTypescript(p) && isForeignBinding(path, p, p.node.name)) {
-                identifiers.add(p.node.name);
+                if (p.isIdentifier() || p.parentPath.isJSXMemberExpression()) {
+                    identifiers.add(p.node.name);
+                }
             }
         },
     });
@@ -365,149 +538,266 @@ function getBindings(path) {
     }
     return collected;
 }
-const IMPORT_IDENTITIES = [
-    {
-        type: 'createContext',
-        name: 'createContext',
-        kind: 'named',
-        source: 'solid-js',
-    },
-    {
-        type: 'createContext',
-        name: 'createContext',
-        kind: 'named',
-        source: 'solid-js/web',
-    },
-    { type: 'render', name: 'render', kind: 'named', source: 'solid-js/web' },
-    { type: 'render', name: 'hydrate', kind: 'named', source: 'solid-js/web' },
-];
-function getImportSpecifierName(specifier) {
-    switch (specifier.imported.type) {
-        case 'Identifier':
-            return specifier.imported.name;
-        case 'StringLiteral':
-            return specifier.imported.value;
-    }
-}
-function registerImportSpecifier(state, id, specifier) {
-    switch (specifier.type) {
-        case 'ImportDefaultSpecifier': {
-            if (id.kind === 'default') {
-                state.registrations.identifiers.set(specifier.local, id);
+
+function getDescriptiveName(path, defaultName) {
+    let current = path;
+    while (current) {
+        switch (current.node.type) {
+            case 'FunctionDeclaration':
+            case 'FunctionExpression': {
+                if (current.node.id) {
+                    return current.node.id.name;
+                }
+                break;
             }
-            break;
-        }
-        case 'ImportSpecifier': {
-            if ((id.kind === 'named' &&
-                getImportSpecifierName(specifier) === id.name) ||
-                (id.kind === 'default' &&
-                    getImportSpecifierName(specifier) === 'default')) {
-                state.registrations.identifiers.set(specifier.local, id);
+            case 'VariableDeclarator': {
+                if (current.node.id.type === 'Identifier') {
+                    return current.node.id.name;
+                }
+                break;
             }
-            break;
-        }
-        case 'ImportNamespaceSpecifier': {
-            let current = state.registrations.namespaces.get(specifier.local);
-            if (!current) {
-                current = [];
+            case 'ClassPrivateMethod':
+            case 'ClassMethod':
+            case 'ObjectMethod': {
+                switch (current.node.key.type) {
+                    case 'Identifier':
+                        return current.node.key.name;
+                    case 'PrivateName':
+                        return current.node.key.id.name;
+                }
+                break;
             }
-            current.push(id);
-            state.registrations.namespaces.set(specifier.local, current);
-            break;
         }
+        current = current.parentPath;
     }
+    return defaultName;
 }
-function registerImportSpecifiers(state, p) {
-    for (let i = 0, len = state.imports.length; i < len; i++) {
-        const id = state.imports[i];
-        if (p.node.source.value === id.source) {
-            for (let k = 0, klen = p.node.specifiers.length; k < klen; k++) {
-                registerImportSpecifier(state, id, p.node.specifiers[k]);
+
+function generateUniqueName(path, name) {
+    let uid;
+    let i = 1;
+    do {
+        uid = name + '_' + i;
+        i++;
+    } while (path.scope.hasLabel(uid) ||
+        path.scope.hasBinding(uid) ||
+        path.scope.hasGlobal(uid) ||
+        path.scope.hasReference(uid));
+    const program = path.scope.getProgramParent();
+    program.references[uid] = true;
+    program.uids[uid] = true;
+    return t__namespace.identifier(uid);
+}
+
+const REFRESH_JSX_SKIP = /^\s*@refresh jsx-skip\s*$/;
+function shouldSkipJSX(node) {
+    // Node without leading comments shouldn't be skipped
+    if (node.leadingComments) {
+        for (let i = 0, len = node.leadingComments.length; i < len; i++) {
+            if (REFRESH_JSX_SKIP.test(node.leadingComments[i].value)) {
+                return true;
             }
         }
     }
+    return false;
 }
-function captureIdentifiers(state, path) {
-    path.traverse({
-        ImportDeclaration(p) {
-            if (p.node.importKind === 'value') {
-                registerImportSpecifiers(state, p);
+function skippableJSX(node) {
+    return t__namespace.addComment(node, 'leading', '@refresh jsx-skip');
+}
+function pushAttribute(state, replacement) {
+    const key = 'v' + state.attributes.length;
+    state.attributes.push(t__namespace.jsxAttribute(t__namespace.jsxIdentifier(key), t__namespace.jsxExpressionContainer(replacement)));
+    return key;
+}
+function pushAttributeAndReplace(state, target, replacement) {
+    const key = pushAttribute(state, replacement);
+    target.replaceWith(t__namespace.memberExpression(state.props, t__namespace.identifier(key)));
+}
+function extractJSXExpressionFromNormalAttribute(state, attr) {
+    const value = attr.get('value');
+    if (isPathValid(value, t__namespace.isJSXElement) ||
+        isPathValid(value, t__namespace.isJSXFragment)) {
+        value.replaceWith(t__namespace.jsxExpressionContainer(value.node));
+    }
+    if (isPathValid(value, t__namespace.isJSXExpressionContainer)) {
+        extractJSXExpressionsFromJSXExpressionContainer(state, value);
+    }
+}
+function extractJSXExpressionFromRef(state, attr) {
+    const value = attr.get('value');
+    if (isPathValid(value, t__namespace.isJSXExpressionContainer)) {
+        const expr = value.get('expression');
+        if (isPathValid(expr, t__namespace.isExpression)) {
+            const unwrappedIdentifier = unwrapNode(expr.node, t__namespace.isIdentifier);
+            let replacement;
+            if (unwrappedIdentifier) {
+                const arg = expr.scope.generateUidIdentifier('arg');
+                replacement = t__namespace.arrowFunctionExpression([arg], t__namespace.blockStatement([
+                    t__namespace.ifStatement(t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', unwrappedIdentifier), t__namespace.stringLiteral('function')), t__namespace.blockStatement([
+                        t__namespace.expressionStatement(t__namespace.callExpression(unwrappedIdentifier, [arg])),
+                    ]), t__namespace.blockStatement([
+                        t__namespace.expressionStatement(t__namespace.assignmentExpression('=', unwrappedIdentifier, arg)),
+                    ])),
+                ]));
             }
-        },
-    });
+            else {
+                replacement = expr.node;
+            }
+            pushAttributeAndReplace(state, expr, replacement);
+        }
+    }
 }
-function unwrapExpression(node, key) {
-    switch (node.type) {
-        case 'ParenthesizedExpression':
-        case 'TypeCastExpression':
-        case 'TSAsExpression':
-        case 'TSSatisfiesExpression':
-        case 'TSNonNullExpression':
-        case 'TSInstantiationExpression':
-        case 'TSTypeAssertion':
-            return unwrapExpression(node.expression, key);
-        default:
-            return key(node) ? node : undefined;
+function extractJSXExpressionFromUseDirective(state, id, attr) {
+    const value = attr.get('value');
+    if (isPathValid(value, t__namespace.isJSXExpressionContainer)) {
+        extractJSXExpressionsFromJSXExpressionContainer(state, value);
     }
+    const key = pushAttribute(state, t__namespace.identifier(id.name));
+    state.vars.push(t__namespace.variableDeclarator(t__namespace.identifier(id.name), t__namespace.memberExpression(state.props, t__namespace.identifier(key))));
 }
-function isIdentifierValidCallee(state, path, callee, target) {
-    const binding = path.scope.getBindingIdentifier(callee.name);
-    if (binding) {
-        const result = state.registrations.identifiers.get(binding);
-        if (result && result.type === target) {
-            return true;
+function extractJSXExpressionFromAttribute(state, attr) {
+    const key = attr.get('name');
+    if (isPathValid(key, t__namespace.isJSXIdentifier)) {
+        if (key.node.name === 'ref') {
+            extractJSXExpressionFromRef(state, attr);
+        }
+        else {
+            extractJSXExpressionFromNormalAttribute(state, attr);
+        }
+    }
+    else if (isPathValid(key, t__namespace.isJSXNamespacedName)) {
+        if (key.node.namespace.name === 'use') {
+            extractJSXExpressionFromUseDirective(state, key.node.name, attr);
+        }
+        else {
+            extractJSXExpressionFromNormalAttribute(state, attr);
         }
     }
-    return false;
 }
-function isPropertyValidCallee(result, target, propName) {
-    for (let i = 0, len = result.length; i < len; i++) {
-        const registration = result[i];
-        if (registration.type === target) {
-            if (registration.kind === 'default') {
-                if (propName === 'default') {
-                    return true;
-                }
-            }
-            else if (registration.kind === 'named' &&
-                registration.name === propName) {
-                return true;
-            }
+function extractJSXExpressionsFromAttributes(state, path) {
+    const openingElement = path.get('openingElement');
+    const attrs = openingElement.get('attributes');
+    for (let i = 0, len = attrs.length; i < len; i++) {
+        const attr = attrs[i];
+        if (isPathValid(attr, t__namespace.isJSXAttribute)) {
+            extractJSXExpressionFromAttribute(state, attr);
+        }
+        if (isPathValid(attr, t__namespace.isJSXSpreadAttribute)) {
+            const arg = attr.get('argument');
+            pushAttributeAndReplace(state, arg, arg.node);
         }
     }
-    return false;
 }
-function isMemberExpressionValidCallee(state, path, member, target) {
-    if (!t__namespace.isIdentifier(member.property)) {
-        return false;
+function convertJSXOpeningToExpression(node) {
+    if (t__namespace.isJSXIdentifier(node)) {
+        return t__namespace.identifier(node.name);
     }
-    const trueObject = unwrapExpression(member.object, t__namespace.isIdentifier);
-    if (!trueObject) {
-        return false;
+    return t__namespace.memberExpression(convertJSXOpeningToExpression(node.object), convertJSXOpeningToExpression(node.property));
+}
+function extractJSXExpressionsFromJSXElement(state, path) {
+    const openingElement = path.get('openingElement');
+    const openingName = openingElement.get('name');
+    if ((isPathValid(openingName, t__namespace.isJSXIdentifier) &&
+        /^[A-Z_]/.test(openingName.node.name)) ||
+        isPathValid(openingName, t__namespace.isJSXMemberExpression)) {
+        const key = pushAttribute(state, convertJSXOpeningToExpression(openingName.node));
+        const replacement = t__namespace.jsxMemberExpression(t__namespace.jsxIdentifier(state.props.name), t__namespace.jsxIdentifier(key));
+        openingName.replaceWith(replacement);
+        const closingElement = path.get('closingElement');
+        if (isPathValid(closingElement, t__namespace.isJSXClosingElement)) {
+            closingElement.get('name').replaceWith(replacement);
+        }
     }
-    const binding = path.scope.getBindingIdentifier(trueObject.name);
-    if (!binding) {
-        return false;
+    extractJSXExpressionsFromAttributes(state, path);
+}
+function extractJSXExpressionsFromJSXExpressionContainer(state, child) {
+    const expr = child.get('expression');
+    if (isPathValid(expr, t__namespace.isExpression)) {
+        pushAttributeAndReplace(state, expr, expr.node);
     }
-    const result = state.registrations.namespaces.get(binding);
-    if (!result) {
-        return false;
+}
+function extractJSXExpressionsFromJSXSpreadChild(state, child) {
+    const arg = child.get('expression');
+    pushAttributeAndReplace(state, arg, arg.node);
+}
+function extractJSXExpressions(state, path) {
+    if (isPathValid(path, t__namespace.isJSXElement)) {
+        extractJSXExpressionsFromJSXElement(state, path);
+    }
+    const children = path.get('children');
+    for (let i = 0, len = children.length; i < len; i++) {
+        const child = children[i];
+        if (isPathValid(child, t__namespace.isJSXElement) ||
+            isPathValid(child, t__namespace.isJSXFragment)) {
+            extractJSXExpressions(state, child);
+        }
+        else if (isPathValid(child, t__namespace.isJSXExpressionContainer)) {
+            extractJSXExpressionsFromJSXExpressionContainer(state, child);
+        }
+        else if (isPathValid(child, t__namespace.isJSXSpreadChild)) {
+            extractJSXExpressionsFromJSXSpreadChild(state, child);
+        }
     }
-    return isPropertyValidCallee(result, target, member.property.name);
 }
-function isValidCallee(state, path, { callee }, target) {
-    if (t__namespace.isV8IntrinsicIdentifier(callee)) {
-        return false;
+function transformJSX(path) {
+    if (shouldSkipJSX(path.node)) {
+        return;
     }
-    const trueCallee = unwrapExpression(callee, t__namespace.isIdentifier);
-    if (trueCallee) {
-        return isIdentifierValidCallee(state, path, trueCallee, target);
+    const state = {
+        props: path.scope.generateUidIdentifier('props'),
+        attributes: [],
+        vars: [],
+    };
+    extractJSXExpressions(state, path);
+    const descriptiveName = getDescriptiveName(path, 'template');
+    const id = generateUniqueName(path, isComponentishName(descriptiveName)
+        ? descriptiveName
+        : 'JSX_' + descriptiveName);
+    const rootPath = getRootStatementPath(path);
+    let template = skippableJSX(t__namespace.cloneNode(path.node));
+    if (state.vars.length) {
+        template = t__namespace.blockStatement([
+            t__namespace.variableDeclaration('const', state.vars),
+            t__namespace.returnStatement(template),
+        ]);
     }
-    const trueMember = unwrapExpression(callee, t__namespace.isMemberExpression);
-    if (trueMember && !trueMember.computed) {
-        return isMemberExpressionValidCallee(state, path, trueMember, target);
+    const templateComp = t__namespace.arrowFunctionExpression([state.props], template);
+    if (path.node.loc) {
+        templateComp.loc = path.node.loc;
     }
-    return false;
+    rootPath.insertBefore(t__namespace.variableDeclaration('const', [t__namespace.variableDeclarator(id, templateComp)]));
+    path.replaceWith(skippableJSX(t__namespace.jsxElement(t__namespace.jsxOpeningElement(t__namespace.jsxIdentifier(id.name), [...state.attributes], true), t__namespace.jsxClosingElement(t__namespace.jsxIdentifier(id.name)), [], true)));
+}
+
+// https://github.com/babel/babel/issues/15269
+let generator;
+if (typeof _generator !== 'function') {
+    generator = _generator.default;
+}
+else {
+    generator = _generator;
+}
+function generateCode(node) {
+    return generator(node).code;
+}
+
+const CWD = process.cwd();
+function getFile(filename) {
+    return path.relative(CWD, filename);
+}
+function createSignatureValue(node) {
+    const code = generateCode(node);
+    const result = xxHash32(code).toString(16);
+    return result;
+}
+function captureIdentifiers(state, path) {
+    path.traverse({
+        ImportDeclaration(p) {
+            if (p.node.importKind === 'value') {
+                registerImportSpecifiers(state, p, state.specifiers);
+            }
+        },
+    });
 }
 function checkValidRenderCall(path) {
     let currentPath = path.parentPath;
@@ -525,7 +815,7 @@ function checkValidRenderCall(path) {
 function fixRenderCalls(state, path) {
     path.traverse({
         ExpressionStatement(p) {
-            const trueCallExpr = unwrapExpression(p.node.expression, t__namespace.isCallExpression);
+            const trueCallExpr = unwrapNode(p.node.expression, t__namespace.isCallExpression);
             if (trueCallExpr &&
                 checkValidRenderCall(p) &&
                 isValidCallee(state, p, trueCallExpr, 'render')) {
@@ -546,7 +836,7 @@ function wrapComponent(state, path, identifier, component, original = component)
     if (statementPath) {
         const registry = createRegistry(state, statementPath);
         const hotName = t__namespace.stringLiteral(identifier.name);
-        const componentCall = getSolidRefreshIdentifier(state, statementPath, IMPORTS.component);
+        const componentCall = getImportIdentifier(state, statementPath, IMPORT_COMPONENT);
         const properties = [];
         if (state.filename && original.loc) {
             const filePath = getFile(state.filename);
@@ -554,7 +844,7 @@ function wrapComponent(state, path, identifier, component, original = component)
         }
         if (state.granular) {
             properties.push(t__namespace.objectProperty(t__namespace.identifier('signature'), t__namespace.stringLiteral(createSignatureValue(component))));
-            const dependencies = getBindings(path);
+            const dependencies = getForeignBindings(path);
             if (dependencies.length) {
                 const dependencyKeys = [];
                 let id;
@@ -564,18 +854,12 @@ function wrapComponent(state, path, identifier, component, original = component)
                 }
                 properties.push(t__namespace.objectProperty(t__namespace.identifier('dependencies'), t__namespace.arrowFunctionExpression([], t__namespace.objectExpression(dependencyKeys))));
             }
-            return t__namespace.callExpression(componentCall, [
-                registry,
-                hotName,
-                component,
-                t__namespace.objectExpression(properties),
-            ]);
         }
         return t__namespace.callExpression(componentCall, [
             registry,
             hotName,
             component,
-            ...(properties.length ? [t__namespace.objectExpression(properties)] : []),
+            t__namespace.objectExpression(properties),
         ]);
     }
     return component;
@@ -585,21 +869,15 @@ function wrapContext(state, path, identifier, context) {
     if (statementPath) {
         const registry = createRegistry(state, statementPath);
         const hotName = t__namespace.stringLiteral(identifier.name);
-        const contextCall = getSolidRefreshIdentifier(state, statementPath, IMPORTS.context);
+        const contextCall = getImportIdentifier(state, statementPath, IMPORT_CONTEXT);
         return t__namespace.callExpression(contextCall, [registry, hotName, context]);
     }
     return context;
 }
-function setupProgram(state, path) {
-    var _a;
+function setupProgram(state, path, comments) {
     let shouldSkip = false;
-    const comments = state.file.ast.comments;
     if (comments) {
         for (const { value: comment } of comments) {
-            if (/^\s*@refresh granular\s*$/.test(comment)) {
-                state.granular = true;
-                break;
-            }
             if (/^\s*@refresh skip\s*$/.test(comment)) {
                 state.processed = true;
                 shouldSkip = true;
@@ -613,39 +891,20 @@ function setupProgram(state, path) {
         }
     }
     captureIdentifiers(state, path);
-    if (!shouldSkip && ((_a = state.opts.fixRender) !== null && _a !== void 0 ? _a : true)) {
+    if (!shouldSkip && state.fixRender) {
         fixRenderCalls(state, path);
     }
 }
-function transformExportNamedDeclaration(state, path) {
-    if (state.processed) {
-        return;
-    }
-    const decl = path.node.declaration;
-    // Check if declaration is FunctionDeclaration
-    if (t__namespace.isFunctionDeclaration(decl) &&
-        !(decl.generator || decl.async) &&
-        // Might be component-like, but the only valid components
-        // have zero or one parameter
-        decl.params.length < 2) {
-        // Check if the declaration has an identifier, and then check
-        // if the name is component-ish
-        if (decl.id && isComponentishName(decl.id.name)) {
-            path.node.declaration = t__namespace.variableDeclaration('const', [
-                t__namespace.variableDeclarator(decl.id, wrapComponent(state, path, decl.id, t__namespace.functionExpression(decl.id, decl.params, decl.body), decl)),
-            ]);
-        }
-    }
-}
 function isStatementTopLevel(path) {
+    let blockParent = path.scope.getBlockParent();
     const programParent = path.scope.getProgramParent();
-    const blockParent = path.scope.getBlockParent();
+    // a FunctionDeclaration binding refers to itself as the block parent
+    if (blockParent.path === path) {
+        blockParent = blockParent.parent;
+    }
     return programParent === blockParent;
 }
 function transformVariableDeclarator(state, path) {
-    if (state.processed) {
-        return;
-    }
     if (path.parentPath.isVariableDeclaration() &&
         !isStatementTopLevel(path.parentPath)) {
         return;
@@ -656,8 +915,8 @@ function transformVariableDeclarator(state, path) {
         return;
     }
     if (isComponentishName(identifier.name)) {
-        const trueFuncExpr = unwrapExpression(init, t__namespace.isFunctionExpression) ||
-            unwrapExpression(init, t__namespace.isArrowFunctionExpression);
+        const trueFuncExpr = unwrapNode(init, t__namespace.isFunctionExpression) ||
+            unwrapNode(init, t__namespace.isArrowFunctionExpression);
         // Check for valid FunctionExpression or ArrowFunctionExpression
         if (trueFuncExpr &&
             // Must not be async or generator
@@ -669,73 +928,111 @@ function transformVariableDeclarator(state, path) {
         }
     }
     // For `createContext` calls
-    const trueCallExpr = unwrapExpression(init, t__namespace.isCallExpression);
+    const trueCallExpr = unwrapNode(init, t__namespace.isCallExpression);
     if (trueCallExpr &&
         isValidCallee(state, path, trueCallExpr, 'createContext')) {
         path.node.init = wrapContext(state, path, identifier, trueCallExpr);
     }
+    path.skip();
+}
+function transformFunctionDeclaration(state, path) {
+    if (isStatementTopLevel(path)) {
+        const decl = path.node;
+        // Check if declaration is FunctionDeclaration
+        if (
+        // Check if the declaration has an identifier, and then check
+        decl.id &&
+            // if the name is component-ish
+            isComponentishName(decl.id.name) &&
+            !(decl.generator || decl.async) &&
+            // Might be component-like, but the only valid components
+            // have zero or one parameter
+            decl.params.length < 2) {
+            path.replaceWith(t__namespace.variableDeclaration('const', [
+                t__namespace.variableDeclarator(decl.id, wrapComponent(state, path, decl.id, t__namespace.functionExpression(decl.id, decl.params, decl.body), decl)),
+            ]));
+            path.skip();
+        }
+    }
+}
+function bubbleFunctionDeclaration(program, path) {
+    if (isStatementTopLevel(path)) {
+        const decl = path.node;
+        // Check if declaration is FunctionDeclaration
+        if (
+        // Check if the declaration has an identifier, and then check
+        decl.id &&
+            // if the name is component-ish
+            isComponentishName(decl.id.name) &&
+            !(decl.generator || decl.async) &&
+            // Might be component-like, but the only valid components
+            // have zero or one parameter
+            decl.params.length < 2) {
+            const first = program.get('body')[0];
+            const [tmp] = first.insertBefore(decl);
+            tmp.skip();
+            if (path.parentPath.isExportNamedDeclaration()) {
+                path.parentPath.replaceWith(t__namespace.exportNamedDeclaration(undefined, [
+                    t__namespace.exportSpecifier(decl.id, decl.id),
+                ]));
+            }
+            else if (path.parentPath.isExportDefaultDeclaration()) {
+                path.replaceWith(decl.id);
+            }
+            else {
+                path.remove();
+            }
+        }
+    }
 }
 function solidRefreshPlugin() {
     return {
-        name: 'Solid Refresh',
-        pre() {
-            this.hooks = new Map();
-            this.processed = false;
-            this.granular = false;
-            this.registrations = {
-                identifiers: new Map(),
-                namespaces: new Map(),
-            };
-            this.imports = [...IMPORT_IDENTITIES, ...(this.opts.imports || [])];
-        },
+        name: 'solid-refresh',
         visitor: {
-            Program(programPath, state) {
-                setupProgram(state, programPath);
+            Program(programPath, context) {
+                var _a, _b;
+                const state = {
+                    granular: (_a = context.opts.granular) !== null && _a !== void 0 ? _a : true,
+                    opts: context.opts,
+                    specifiers: [...IMPORT_SPECIFIERS],
+                    imports: new Map(),
+                    registrations: {
+                        identifiers: new Map(),
+                        namespaces: new Map(),
+                    },
+                    processed: false,
+                    filename: context.filename,
+                    bundler: context.opts.bundler || 'standard',
+                    fixRender: (_b = context.opts.fixRender) !== null && _b !== void 0 ? _b : true,
+                };
+                setupProgram(state, programPath, context.file.ast.comments);
+                if (state.processed) {
+                    return;
+                }
+                programPath.traverse({
+                    FunctionDeclaration(path) {
+                        bubbleFunctionDeclaration(programPath, path);
+                    },
+                });
+                programPath.scope.crawl();
                 programPath.traverse({
-                    ExportNamedDeclaration(path) {
-                        transformExportNamedDeclaration(state, path);
+                    JSXElement(path) {
+                        transformJSX(path);
+                    },
+                    JSXFragment(path) {
+                        transformJSX(path);
                     },
+                });
+                programPath.scope.crawl();
+                programPath.traverse({
                     VariableDeclarator(path) {
                         transformVariableDeclarator(state, path);
                     },
                     FunctionDeclaration(path) {
-                        if (state.processed) {
-                            return;
-                        }
-                        if (path.parentPath.isProgram() ||
-                            path.parentPath.isExportDefaultDeclaration()) {
-                            const decl = path.node;
-                            // Check if declaration is FunctionDeclaration
-                            if (
-                            // Check if the declaration has an identifier, and then check
-                            decl.id &&
-                                // if the name is component-ish
-                                isComponentishName(decl.id.name) &&
-                                !(decl.generator || decl.async) &&
-                                // Might be component-like, but the only valid components
-                                // have zero or one parameter
-                                decl.params.length < 2) {
-                                const replacement = wrapComponent(state, path, decl.id, t__namespace.functionExpression(decl.id, decl.params, decl.body), decl);
-                                const newDecl = t__namespace.variableDeclaration('var', [
-                                    t__namespace.variableDeclarator(decl.id, replacement),
-                                ]);
-                                if (path.parentPath.isExportDefaultDeclaration()) {
-                                    const parent = path.parentPath
-                                        .parentPath;
-                                    const first = parent.get('body')[0];
-                                    first.insertBefore(newDecl);
-                                    path.replaceWith(decl.id);
-                                }
-                                else {
-                                    const parent = path.parentPath;
-                                    const first = parent.get('body')[0];
-                                    first.insertBefore(newDecl);
-                                    path.remove();
-                                }
-                            }
-                        }
+                        transformFunctionDeclaration(state, path);
                     },
                 });
+                programPath.scope.crawl();
             },
         },
     };