solid-refresh 0.7.1 → 0.7.3

package/dist/babel.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
-var path = require('path');
 var t = require('@babel/types');
-var helperModuleImports = require('@babel/helper-module-imports');
+var path = require('path');
 var _generator = require('@babel/generator');
 
 function _interopNamespaceDefault(e) {
@@ -24,193 +23,6 @@ function _interopNamespaceDefault(e) {
 
 var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
 
-/**
- * Copyright (c) 2019 Jason Dent
- * https://github.com/Jason3S/xxhash
- */
-const PRIME32_1 = 2654435761;
-const PRIME32_2 = 2246822519;
-const PRIME32_3 = 3266489917;
-const PRIME32_4 = 668265263;
-const PRIME32_5 = 374761393;
-function toUtf8(text) {
-    const bytes = [];
-    for (let i = 0, n = text.length; i < n; ++i) {
-        const c = text.charCodeAt(i);
-        if (c < 0x80) {
-            bytes.push(c);
-        }
-        else if (c < 0x800) {
-            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
-        }
-        else if (c < 0xd800 || c >= 0xe000) {
-            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
-        }
-        else {
-            const cp = 0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
-            bytes.push(0xf0 | ((cp >> 18) & 0x7), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
-        }
-    }
-    return new Uint8Array(bytes);
-}
-/**
- *
- * @param buffer - byte array or string
- * @param seed - optional seed (32-bit unsigned);
- */
-function xxHash32(buffer, seed = 0) {
-    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
-    const b = buffer;
-    /*
-          Step 1. Initialize internal accumulators
-          Each accumulator gets an initial value based on optional seed input. Since the seed is optional, it can be 0.
-          ```
-              u32 acc1 = seed + PRIME32_1 + PRIME32_2;
-              u32 acc2 = seed + PRIME32_2;
-              u32 acc3 = seed + 0;
-              u32 acc4 = seed - PRIME32_1;
-          ```
-          Special case : input is less than 16 bytes
-          When input is too small (< 16 bytes), the algorithm will not process any stripe. Consequently, it will not
-          make use of parallel accumulators.
-          In which case, a simplified initialization is performed, using a single accumulator :
-          u32 acc  = seed + PRIME32_5;
-          The algorithm then proceeds directly to step 4.
-      */
-    let acc = (seed + PRIME32_5) & 0xffffffff;
-    let offset = 0;
-    if (b.length >= 16) {
-        const accN = [
-            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
-            (seed + PRIME32_2) & 0xffffffff,
-            (seed + 0) & 0xffffffff,
-            (seed - PRIME32_1) & 0xffffffff,
-        ];
-        /*
-                Step 2. Process stripes
-                A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes, of 4 bytes each.
-                The first lane is used to update accumulator 1, the second lane is used to update accumulator 2, and so on.
-                Each lane read its associated 32-bit value using little-endian convention.
-                For each {lane, accumulator}, the update process is called a round, and applies the following formula :
-                ```
-                accN = accN + (laneN * PRIME32_2);
-                accN = accN <<< 13;
-                accN = accN * PRIME32_1;
-                ```
-                This shuffles the bits so that any bit from input lane impacts several bits in output accumulator.
-                All operations are performed modulo 2^32.
-                Input is consumed one full stripe at a time. Step 2 is looped as many times as necessary to consume
-                the whole input, except the last remaining bytes which cannot form a stripe (< 16 bytes). When that
-                happens, move to step 3.
-            */
-        const b = buffer;
-        const limit = b.length - 16;
-        let lane = 0;
-        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
-            const i = offset;
-            const laneN0 = b[i + 0] + (b[i + 1] << 8);
-            const laneN1 = b[i + 2] + (b[i + 3] << 8);
-            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
-            let acc = (accN[lane] + laneNP) & 0xffffffff;
-            acc = (acc << 13) | (acc >>> 19);
-            const acc0 = acc & 0xffff;
-            const acc1 = acc >>> 16;
-            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
-            lane = (lane + 1) & 0x3;
-        }
-        /*
-                Step 3. Accumulator convergence
-                All 4 lane accumulators from previous steps are merged to produce a single remaining accumulator
-                of same width (32-bit). The associated formula is as follows :
-                ```
-                acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
-                ```
-            */
-        acc =
-            (((accN[0] << 1) | (accN[0] >>> 31)) +
-                ((accN[1] << 7) | (accN[1] >>> 25)) +
-                ((accN[2] << 12) | (accN[2] >>> 20)) +
-                ((accN[3] << 18) | (accN[3] >>> 14))) &
-                0xffffffff;
-    }
-    /*
-          Step 4. Add input length
-          The input total length is presumed known at this stage. This step is just about adding the length to
-          accumulator, so that it participates to final mixing.
-          ```
-          acc = acc + (u32)inputLength;
-          ```
-      */
-    acc = (acc + buffer.length) & 0xffffffff;
-    /*
-          Step 5. Consume remaining input
-          There may be up to 15 bytes remaining to consume from the input. The final stage will digest them according
-          to following pseudo-code :
-          ```
-          while (remainingLength >= 4) {
-              lane = read_32bit_little_endian(input_ptr);
-              acc = acc + lane * PRIME32_3;
-              acc = (acc <<< 17) * PRIME32_4;
-              input_ptr += 4; remainingLength -= 4;
-          }
-          ```
-          This process ensures that all input bytes are present in the final mix.
-      */
-    const limit = buffer.length - 4;
-    for (; offset <= limit; offset += 4) {
-        const i = offset;
-        const laneN0 = b[i + 0] + (b[i + 1] << 8);
-        const laneN1 = b[i + 2] + (b[i + 3] << 8);
-        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
-        acc = (acc + laneP) & 0xffffffff;
-        acc = (acc << 17) | (acc >>> 15);
-        acc =
-            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
-                0xffffffff;
-    }
-    /*
-          ```
-          while (remainingLength >= 1) {
-              lane = read_byte(input_ptr);
-              acc = acc + lane * PRIME32_5;
-              acc = (acc <<< 11) * PRIME32_1;
-              input_ptr += 1; remainingLength -= 1;
-          }
-          ```
-      */
-    for (; offset < b.length; ++offset) {
-        const lane = b[offset];
-        acc = acc + lane * PRIME32_5;
-        acc = (acc << 11) | (acc >>> 21);
-        acc =
-            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
-                0xffffffff;
-    }
-    /*
-          Step 6. Final mix (avalanche)
-          The final mix ensures that all input bits have a chance to impact any bit in the output digest,
-          resulting in an unbiased distribution. This is also called avalanche effect.
-          ```
-          acc = acc xor (acc >> 15);
-          acc = acc * PRIME32_2;
-          acc = acc xor (acc >> 13);
-          acc = acc * PRIME32_3;
-          acc = acc xor (acc >> 16);
-          ```
-      */
-    acc = acc ^ (acc >>> 15);
-    acc =
-        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_2) << 16);
-    acc = acc ^ (acc >>> 13);
-    acc =
-        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_3) << 16);
-    acc = acc ^ (acc >>> 16);
-    // turn any negatives back into a positive number;
-    return acc < 0 ? acc + 4294967296 : acc;
-}
-
 // This is just a Pascal heuristic
 // we only assume a function is a component
 // if the first character is in uppercase
@@ -224,71 +36,6 @@ function getImportSpecifierName(specifier) {
     return specifier.imported.value;
 }
 
-function registerImportSpecifier(state, id, specifier) {
-    if (t__namespace.isImportDefaultSpecifier(specifier)) {
-        if (id.definition.kind === 'default') {
-            state.registrations.identifiers.set(specifier.local, id);
-        }
-        return;
-    }
-    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) {
-    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'));
-    }
-}
-
-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;
-    }
-    const newID = registration.kind === 'named'
-        ? helperModuleImports.addNamed(path, registration.name, registration.source)
-        : helperModuleImports.addDefault(path, registration.source);
-    state.imports.set(target, newID);
-    return newID;
-}
-
 // Source of solid-refresh (for import)
 const SOLID_REFRESH_MODULE = 'solid-refresh';
 // Exported names from solid-refresh that will be imported
@@ -344,6 +91,54 @@ const IMPORT_SPECIFIERS = [
     },
 ];
 
+function getHotIdentifier(state) {
+    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'));
+    }
+}
+
+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;
+    }
+    const programParent = path.scope.getProgramParent();
+    const uid = programParent.generateUidIdentifier(registration.kind === 'named' ? registration.name : 'default');
+    const newPath = programParent.path.unshiftContainer('body', t__namespace.importDeclaration([
+        registration.kind === 'named'
+            ? t__namespace.importSpecifier(uid, t__namespace.identifier(registration.name))
+            : t__namespace.importDefaultSpecifier(uid),
+    ], t__namespace.stringLiteral(registration.source)))[0];
+    programParent.registerDeclaration(newPath);
+    state.imports.set(target, uid);
+    return uid;
+}
+
+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;
+}
+
 function generateViteHMRRequirement(state, statements, pathToHot) {
     if (state.bundler === 'vite') {
         // Vite requires that the owner module has an `import.meta.hot.accept()` call
@@ -351,6 +146,87 @@ function generateViteHMRRequirement(state, statements, pathToHot) {
     }
 }
 
+const REGISTRY = 'REGISTRY';
+function createRegistry(state, path) {
+    const current = state.imports.get(REGISTRY);
+    if (current) {
+        return current;
+    }
+    const root = getRootStatementPath(path);
+    const identifier = path.scope.generateUidIdentifier(REGISTRY);
+    const [tmp] = root.insertBefore(t__namespace.variableDeclaration('const', [
+        t__namespace.variableDeclarator(identifier, t__namespace.callExpression(getImportIdentifier(state, path, IMPORT_REGISTRY), [])),
+    ]));
+    root.scope.registerDeclaration(tmp);
+    const pathToHot = getHotIdentifier(state);
+    const statements = [
+        t__namespace.expressionStatement(t__namespace.callExpression(getImportIdentifier(state, path, IMPORT_REFRESH), [
+            t__namespace.stringLiteral(state.bundler),
+            pathToHot,
+            identifier,
+        ])),
+    ];
+    generateViteHMRRequirement(state, statements, pathToHot);
+    path.scope.getProgramParent().path.pushContainer('body', [
+        t__namespace.ifStatement(pathToHot, t__namespace.blockStatement(statements)),
+    ]);
+    state.imports.set(REGISTRY, identifier);
+    return identifier;
+}
+
+// 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;
+}
+
+function isForeignBinding(source, current, name) {
+    if (source === current) {
+        return true;
+    }
+    if (current.scope.hasOwnBinding(name)) {
+        return false;
+    }
+    if (current.parentPath) {
+        return isForeignBinding(source, current.parentPath, name);
+    }
+    return true;
+}
+function isInTypescript(path) {
+    let parent = path.parentPath;
+    while (parent) {
+        if (t__namespace.isTypeScript(parent.node) && !t__namespace.isExpression(parent.node)) {
+            return true;
+        }
+        parent = parent.parentPath;
+    }
+    return false;
+}
+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)) {
+                if (p.isIdentifier() || p.parentPath.isJSXMemberExpression()) {
+                    identifiers.add(p.node.name);
+                }
+            }
+        },
+    });
+    const collected = [];
+    for (const identifier of identifiers) {
+        collected.push(t__namespace.identifier(identifier));
+    }
+    return collected;
+}
+
 function getHMRDeclineCall(state, path) {
     const pathToHot = getHotIdentifier(state);
     const statements = [
@@ -363,6 +239,16 @@ function getHMRDeclineCall(state, path) {
     return t__namespace.ifStatement(pathToHot, t__namespace.blockStatement(statements));
 }
 
+function getStatementPath(path) {
+    if (t__namespace.isStatement(path.node)) {
+        return path;
+    }
+    if (path.parentPath) {
+        return getStatementPath(path.parentPath);
+    }
+    return null;
+}
+
 function isPathValid(path, key) {
     return key(path.node);
 }
@@ -432,111 +318,57 @@ function isMemberExpressionValidCallee(state, path, member, target) {
     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;
-    }
-    if (path.parentPath) {
-        return getStatementPath(path.parentPath);
-    }
-    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) {
-    const current = state.imports.get(REGISTRY);
-    if (current) {
-        return current;
-    }
-    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(getImportIdentifier(state, path, IMPORT_REFRESH), [
-            t__namespace.stringLiteral(state.bundler),
-            pathToHot,
-            identifier,
-        ])),
-    ];
-    generateViteHMRRequirement(state, statements, pathToHot);
-    path.scope.getProgramParent().path.pushContainer('body', [
-        t__namespace.ifStatement(pathToHot, t__namespace.blockStatement(statements)),
-    ]);
-    state.imports.set(REGISTRY, identifier);
-    return identifier;
-}
-
-function isForeignBinding(source, current, name) {
-    if (source === current) {
-        return true;
-    }
-    if (current.scope.hasOwnBinding(name)) {
+    return isPropertyValidCallee(result, target, member.property.name);
+}
+function isValidCallee(state, path, { callee }, target) {
+    if (t__namespace.isV8IntrinsicIdentifier(callee)) {
         return false;
     }
-    if (current.parentPath) {
-        return isForeignBinding(source, current.parentPath, name);
+    const trueCallee = unwrapNode(callee, t__namespace.isIdentifier);
+    if (trueCallee) {
+        return isIdentifierValidCallee(state, path, trueCallee, target);
     }
-    return true;
+    const trueMember = unwrapNode(callee, t__namespace.isMemberExpression);
+    if (trueMember && !trueMember.computed) {
+        return isMemberExpressionValidCallee(state, path, trueMember, target);
+    }
+    return false;
 }
-function isInTypescript(path) {
-    let parent = path.parentPath;
-    while (parent) {
-        if (t__namespace.isTypeScript(parent.node) && !t__namespace.isExpression(parent.node)) {
-            return true;
+
+function registerImportSpecifier(state, id, specifier) {
+    if (t__namespace.isImportDefaultSpecifier(specifier)) {
+        if (id.definition.kind === 'default') {
+            state.registrations.identifiers.set(specifier.local, id);
         }
-        parent = parent.parentPath;
+        return;
     }
-    return false;
+    if (t__namespace.isImportSpecifier(specifier)) {
+        if (specifier.importKind === 'type' || specifier.importKind === 'typeof') {
+            return;
+        }
+        const name = getImportSpecifierName(specifier);
+        if ((id.definition.kind === 'named' && name === id.definition.name) ||
+            (id.definition.kind === 'default' && name === '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 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)) {
-                if (p.isIdentifier() || p.parentPath.isJSXMemberExpression()) {
-                    identifiers.add(p.node.name);
-                }
+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]);
             }
-        },
-    });
-    const collected = [];
-    for (const identifier of identifiers) {
-        collected.push(t__namespace.identifier(identifier));
+        }
     }
-    return collected;
 }
 
 function getDescriptiveName(path, defaultName) {
@@ -765,20 +597,196 @@ function transformJSX(path) {
     if (path.node.loc) {
         templateComp.loc = path.node.loc;
     }
-    rootPath.insertBefore(t__namespace.variableDeclaration('const', [t__namespace.variableDeclarator(id, templateComp)]));
+    const [tmp] = rootPath.insertBefore(t__namespace.variableDeclaration('const', [t__namespace.variableDeclarator(id, templateComp)]));
+    rootPath.scope.registerDeclaration(tmp);
     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;
+/**
+ * Copyright (c) 2019 Jason Dent
+ * https://github.com/Jason3S/xxhash
+ */
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+function toUtf8(text) {
+    const bytes = [];
+    for (let i = 0, n = text.length; i < n; ++i) {
+        const c = text.charCodeAt(i);
+        if (c < 0x80) {
+            bytes.push(c);
+        }
+        else if (c < 0x800) {
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            const cp = 0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
+            bytes.push(0xf0 | ((cp >> 18) & 0x7), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
 }
-function generateCode(node) {
-    return generator(node).code;
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+function xxHash32(buffer, seed = 0) {
+    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+    const b = buffer;
+    /*
+          Step 1. Initialize internal accumulators
+          Each accumulator gets an initial value based on optional seed input. Since the seed is optional, it can be 0.
+          ```
+              u32 acc1 = seed + PRIME32_1 + PRIME32_2;
+              u32 acc2 = seed + PRIME32_2;
+              u32 acc3 = seed + 0;
+              u32 acc4 = seed - PRIME32_1;
+          ```
+          Special case : input is less than 16 bytes
+          When input is too small (< 16 bytes), the algorithm will not process any stripe. Consequently, it will not
+          make use of parallel accumulators.
+          In which case, a simplified initialization is performed, using a single accumulator :
+          u32 acc  = seed + PRIME32_5;
+          The algorithm then proceeds directly to step 4.
+      */
+    let acc = (seed + PRIME32_5) & 0xffffffff;
+    let offset = 0;
+    if (b.length >= 16) {
+        const accN = [
+            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+            (seed + PRIME32_2) & 0xffffffff,
+            (seed + 0) & 0xffffffff,
+            (seed - PRIME32_1) & 0xffffffff,
+        ];
+        /*
+                Step 2. Process stripes
+                A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes, of 4 bytes each.
+                The first lane is used to update accumulator 1, the second lane is used to update accumulator 2, and so on.
+                Each lane read its associated 32-bit value using little-endian convention.
+                For each {lane, accumulator}, the update process is called a round, and applies the following formula :
+                ```
+                accN = accN + (laneN * PRIME32_2);
+                accN = accN <<< 13;
+                accN = accN * PRIME32_1;
+                ```
+                This shuffles the bits so that any bit from input lane impacts several bits in output accumulator.
+                All operations are performed modulo 2^32.
+                Input is consumed one full stripe at a time. Step 2 is looped as many times as necessary to consume
+                the whole input, except the last remaining bytes which cannot form a stripe (< 16 bytes). When that
+                happens, move to step 3.
+            */
+        const b = buffer;
+        const limit = b.length - 16;
+        let lane = 0;
+        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+            const i = offset;
+            const laneN0 = b[i + 0] + (b[i + 1] << 8);
+            const laneN1 = b[i + 2] + (b[i + 3] << 8);
+            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+            let acc = (accN[lane] + laneNP) & 0xffffffff;
+            acc = (acc << 13) | (acc >>> 19);
+            const acc0 = acc & 0xffff;
+            const acc1 = acc >>> 16;
+            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+            lane = (lane + 1) & 0x3;
+        }
+        /*
+                Step 3. Accumulator convergence
+                All 4 lane accumulators from previous steps are merged to produce a single remaining accumulator
+                of same width (32-bit). The associated formula is as follows :
+                ```
+                acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
+                ```
+            */
+        acc =
+            (((accN[0] << 1) | (accN[0] >>> 31)) +
+                ((accN[1] << 7) | (accN[1] >>> 25)) +
+                ((accN[2] << 12) | (accN[2] >>> 20)) +
+                ((accN[3] << 18) | (accN[3] >>> 14))) &
+                0xffffffff;
+    }
+    /*
+          Step 4. Add input length
+          The input total length is presumed known at this stage. This step is just about adding the length to
+          accumulator, so that it participates to final mixing.
+          ```
+          acc = acc + (u32)inputLength;
+          ```
+      */
+    acc = (acc + buffer.length) & 0xffffffff;
+    /*
+          Step 5. Consume remaining input
+          There may be up to 15 bytes remaining to consume from the input. The final stage will digest them according
+          to following pseudo-code :
+          ```
+          while (remainingLength >= 4) {
+              lane = read_32bit_little_endian(input_ptr);
+              acc = acc + lane * PRIME32_3;
+              acc = (acc <<< 17) * PRIME32_4;
+              input_ptr += 4; remainingLength -= 4;
+          }
+          ```
+          This process ensures that all input bytes are present in the final mix.
+      */
+    const limit = buffer.length - 4;
+    for (; offset <= limit; offset += 4) {
+        const i = offset;
+        const laneN0 = b[i + 0] + (b[i + 1] << 8);
+        const laneN1 = b[i + 2] + (b[i + 3] << 8);
+        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+        acc = (acc + laneP) & 0xffffffff;
+        acc = (acc << 17) | (acc >>> 15);
+        acc =
+            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
+                0xffffffff;
+    }
+    /*
+          ```
+          while (remainingLength >= 1) {
+              lane = read_byte(input_ptr);
+              acc = acc + lane * PRIME32_5;
+              acc = (acc <<< 11) * PRIME32_1;
+              input_ptr += 1; remainingLength -= 1;
+          }
+          ```
+      */
+    for (; offset < b.length; ++offset) {
+        const lane = b[offset];
+        acc = acc + lane * PRIME32_5;
+        acc = (acc << 11) | (acc >>> 21);
+        acc =
+            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
+                0xffffffff;
+    }
+    /*
+          Step 6. Final mix (avalanche)
+          The final mix ensures that all input bits have a chance to impact any bit in the output digest,
+          resulting in an unbiased distribution. This is also called avalanche effect.
+          ```
+          acc = acc xor (acc >> 15);
+          acc = acc * PRIME32_2;
+          acc = acc xor (acc >> 13);
+          acc = acc * PRIME32_3;
+          acc = acc xor (acc >> 16);
+          ```
+      */
+    acc = acc ^ (acc >>> 15);
+    acc =
+        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_2) << 16);
+    acc = acc ^ (acc >>> 13);
+    acc =
+        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_3) << 16);
+    acc = acc ^ (acc >>> 16);
+    // turn any negatives back into a positive number;
+    return acc < 0 ? acc + 4294967296 : acc;
 }
 
 const CWD = process.cwd();
@@ -793,7 +801,7 @@ function createSignatureValue(node) {
 function captureIdentifiers(state, path) {
     path.traverse({
         ImportDeclaration(p) {
-            if (p.node.importKind === 'value') {
+            if (!(p.node.importKind === 'type' || p.node.importKind === 'typeof')) {
                 registerImportSpecifiers(state, p, state.specifiers);
             }
         },
@@ -906,6 +914,9 @@ function isStatementTopLevel(path) {
     }
     return programParent === blockParent;
 }
+function isValidFunction(node) {
+    return t__namespace.isArrowFunctionExpression(node) || t__namespace.isFunctionExpression(node);
+}
 function transformVariableDeclarator(state, path) {
     if (path.parentPath.isVariableDeclaration() &&
         !isStatementTopLevel(path.parentPath)) {
@@ -917,8 +928,7 @@ function transformVariableDeclarator(state, path) {
         return;
     }
     if (isComponentishName(identifier.name)) {
-        const trueFuncExpr = unwrapNode(init, t__namespace.isFunctionExpression) ||
-            unwrapNode(init, t__namespace.isArrowFunctionExpression);
+        const trueFuncExpr = unwrapNode(init, isValidFunction);
         // Check for valid FunctionExpression or ArrowFunctionExpression
         if (trueFuncExpr &&
             // Must not be async or generator
@@ -950,9 +960,10 @@ function transformFunctionDeclaration(state, path) {
             // Might be component-like, but the only valid components
             // have zero or one parameter
             decl.params.length < 2) {
-            path.replaceWith(t__namespace.variableDeclaration('const', [
+            const [tmp] = 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.scope.registerDeclaration(tmp);
             path.skip();
         }
     }
@@ -972,6 +983,7 @@ function bubbleFunctionDeclaration(program, path) {
             decl.params.length < 2) {
             const first = program.get('body')[0];
             const [tmp] = first.insertBefore(decl);
+            program.scope.registerDeclaration(tmp);
             tmp.skip();
             if (path.parentPath.isExportNamedDeclaration()) {
                 path.parentPath.replaceWith(t__namespace.exportNamedDeclaration(undefined, [
@@ -1014,7 +1026,6 @@ function solidRefreshPlugin() {
                         bubbleFunctionDeclaration(programPath, path);
                     },
                 });
-                programPath.scope.crawl();
                 programPath.traverse({
                     JSXElement(path) {
                         transformJSX(path);
@@ -1023,7 +1034,6 @@ function solidRefreshPlugin() {
                         transformJSX(path);
                     },
                 });
-                programPath.scope.crawl();
                 programPath.traverse({
                     VariableDeclarator(path) {
                         transformVariableDeclarator(state, path);
@@ -1032,10 +1042,10 @@ function solidRefreshPlugin() {
                         transformFunctionDeclaration(state, path);
                     },
                 });
-                programPath.scope.crawl();
             },
         },
     };
 }
 
 module.exports = solidRefreshPlugin;
+//# sourceMappingURL=babel.cjs.map