@wyw-in-js/transform 0.1.0

package/types/utils/getTagProcessor.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTagProcessor = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const core_1 = require("@babel/core");
+const helper_module_imports_1 = require("@babel/helper-module-imports");
+const processor_utils_1 = require("@wyw-in-js/processor-utils");
+const collectExportsAndImports_1 = require("./collectExportsAndImports");
+const collectTemplateDependencies_1 = require("./collectTemplateDependencies");
+const findPackageJSON_1 = require("./findPackageJSON");
+const getSource_1 = require("./getSource");
+const isNotNull_1 = require("./isNotNull");
+const scopeHelpers_1 = require("./scopeHelpers");
+const traversalCache_1 = require("./traversalCache");
+const last = (arr) => arr[arr.length - 1];
+function zip(arr1, arr2) {
+    const result = [];
+    for (let i = 0; i < arr1.length; i++) {
+        result.push(arr1[i]);
+        if (arr2[i])
+            result.push(arr2[i]);
+    }
+    return result;
+}
+function buildCodeFrameError(path, message) {
+    try {
+        return path.buildCodeFrameError(message);
+    }
+    catch {
+        return new Error(message);
+    }
+}
+const definedTagsCache = new Map();
+const getDefinedTagsFromPackage = (pkgName, filename) => {
+    if (definedTagsCache.has(pkgName)) {
+        return definedTagsCache.get(pkgName);
+    }
+    const packageJSONPath = (0, findPackageJSON_1.findPackageJSON)(pkgName, filename);
+    if (!packageJSONPath) {
+        return undefined;
+    }
+    const packageDir = (0, path_1.dirname)(packageJSONPath);
+    const packageJSON = JSON.parse((0, fs_1.readFileSync)(packageJSONPath, 'utf8'));
+    const definedTags = packageJSON['wyw-in-js']?.tags;
+    const normalizedTags = definedTags
+        ? Object.entries(definedTags).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: value.startsWith('.')
+                ? (0, path_1.join)(packageDir, value)
+                : require.resolve(value, { paths: [packageDir] }),
+        }), {})
+        : undefined;
+    definedTagsCache.set(pkgName, normalizedTags);
+    return normalizedTags;
+};
+function isValidProcessorClass(module) {
+    return module instanceof processor_utils_1.BaseProcessor.constructor;
+}
+function getProcessorFromPackage(packageName, tagName, filename) {
+    const definedTags = getDefinedTagsFromPackage(packageName, filename);
+    const processorPath = definedTags?.[tagName];
+    if (!processorPath) {
+        return null;
+    }
+    const Processor = require(processorPath).default;
+    if (!isValidProcessorClass(Processor)) {
+        return null;
+    }
+    return Processor;
+}
+function getProcessorFromFile(processorPath) {
+    const Processor = require(processorPath).default;
+    if (!isValidProcessorClass(Processor)) {
+        return null;
+    }
+    return Processor;
+}
+function getProcessorForIdentifier(path, imports, filename, options) {
+    const pathBinding = path.scope.getBinding(path.node.name);
+    if (!pathBinding) {
+        // It's not a binding, so it's not a tag
+        return [null, null, null];
+    }
+    const tagResolver = options.tagResolver ?? (() => null);
+    // FIXME: can be simplified
+    const relatedImports = imports
+        .map((i) => {
+        const { local } = i;
+        if (local === path) {
+            return [i, null];
+        }
+        if (!local.isIdentifier()) {
+            if (path.isDescendant(local)) {
+                return [i, local];
+            }
+            return null;
+        }
+        const binding = local.scope.getBinding(local.node.name);
+        if (pathBinding === binding) {
+            return [i, path];
+        }
+        return null;
+    })
+        .filter(isNotNull_1.isNotNull)
+        .filter((i) => i[1] === null || i[1].isExpression());
+    if (relatedImports.length === 0) {
+        return [null, null, null];
+    }
+    const [Processor = null, tagSource = null, tagPath = null] = relatedImports
+        .map(([{ imported, source }, p]) => {
+        const customFile = tagResolver(source, imported);
+        const processor = customFile
+            ? getProcessorFromFile(customFile)
+            : getProcessorFromPackage(source, imported, filename);
+        return [processor, { imported, source }, p];
+    })
+        .find(([proc]) => proc) ?? [];
+    return Processor === null || tagSource === null || tagPath === null
+        ? [null, null, null]
+        : [Processor, tagSource, tagPath];
+}
+function getBuilderForIdentifier(path, imports, filename, options) {
+    const [Processor, tagSource, tagPath] = getProcessorForIdentifier(path, imports, filename, options);
+    if (!Processor || !tagSource || !tagPath) {
+        return null;
+    }
+    const params = [['callee', tagPath.node]];
+    let prev = tagPath;
+    let current = tagPath.parentPath;
+    while (current && current !== path) {
+        if (current?.isSequenceExpression() &&
+            last(current.node.expressions) === prev.node) {
+            prev = current;
+            current = current.parentPath;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (current?.isCallExpression({ callee: prev.node })) {
+            const args = current.get('arguments');
+            const cookedArgs = args
+                .map((arg) => {
+                const buildError = arg.buildCodeFrameError.bind(arg);
+                if (!arg.isExpression()) {
+                    throw buildError(`Unexpected type of an argument ${arg.type}`);
+                }
+                const source = (0, getSource_1.getSource)(arg);
+                const extracted = (0, collectTemplateDependencies_1.extractExpression)(arg, options.evaluate, imports);
+                return {
+                    ...extracted,
+                    source,
+                    buildCodeFrameError: buildError,
+                };
+            })
+                .filter(isNotNull_1.isNotNull);
+            params.push(['call', ...cookedArgs]);
+            prev = current;
+            current = current.parentPath;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (current?.isMemberExpression({ object: prev.node })) {
+            const property = current.get('property');
+            if (property.isIdentifier() && !current.node.computed) {
+                params.push(['member', property.node.name]);
+            }
+            else if (property.isStringLiteral()) {
+                params.push(['member', property.node.value]);
+            }
+            else {
+                throw property.buildCodeFrameError(`Unexpected type of a property`);
+            }
+            prev = current;
+            current = current.parentPath;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (current?.isTaggedTemplateExpression({ tag: prev.node })) {
+            const [quasis, expressionValues] = (0, collectTemplateDependencies_1.collectTemplateDependencies)(current, options.evaluate);
+            params.push(['template', zip(quasis, expressionValues)]);
+            prev = current;
+            current = current.parentPath;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        break;
+    }
+    const replacer = (replacement, isPure) => {
+        (0, scopeHelpers_1.mutate)(prev, (p) => {
+            p.replaceWith(replacement);
+            if (isPure) {
+                p.addComment('leading', '#__PURE__');
+            }
+        });
+    };
+    const astService = {
+        ...core_1.types,
+        addDefaultImport: (importedSource, nameHint) => (0, helper_module_imports_1.addDefault)(path, importedSource, { nameHint }),
+        addNamedImport: (name, importedSource, nameHint = name) => (0, helper_module_imports_1.addNamed)(path, name, importedSource, { nameHint }),
+    };
+    return (...args) => new Processor(params, tagSource, astService, tagPath.node.loc ?? null, replacer, ...args);
+}
+function getDisplayName(path, idx, filename) {
+    let displayName;
+    const parent = path.findParent((p) => p.isObjectProperty() ||
+        p.isJSXOpeningElement() ||
+        p.isVariableDeclarator());
+    if (parent) {
+        if (parent.isObjectProperty()) {
+            if ('name' in parent.node.key) {
+                displayName = parent.node.key.name;
+            }
+            else if ('value' in parent.node.key) {
+                displayName = parent.node.key.value.toString();
+            }
+            else {
+                const keyPath = parent.get('key');
+                displayName = (0, getSource_1.getSource)(keyPath);
+            }
+        }
+        else if (parent.isJSXOpeningElement()) {
+            const name = parent.get('name');
+            if (name.isJSXIdentifier()) {
+                displayName = name.node.name;
+            }
+        }
+        else if (parent.isVariableDeclarator()) {
+            const id = parent.get('id');
+            if (id.isIdentifier()) {
+                displayName = id.node.name;
+            }
+        }
+    }
+    if (!displayName) {
+        // Try to derive the path from the filename
+        displayName = (0, path_1.basename)(filename ?? 'unknown');
+        if (filename && /^index\.[a-z\d]+$/.test(displayName)) {
+            // If the file name is 'index', better to get name from parent folder
+            displayName = (0, path_1.basename)((0, path_1.dirname)(filename));
+        }
+        // Remove the file extension
+        displayName = displayName.replace(/\.[a-z\d]+$/, '');
+        if (displayName) {
+            displayName += idx;
+        }
+        else {
+            throw new Error("Couldn't determine a name for the component. Ensure that it's either:\n" +
+                '- Assigned to a variable\n' +
+                '- Is an object property\n' +
+                '- Is a prop in a JSX element\n');
+        }
+    }
+    return displayName;
+}
+function isTagReferenced(path) {
+    // Check if the variable is referenced anywhere for basic DCE
+    // Only works when it's assigned to a variable
+    let isReferenced = true;
+    const parent = path.findParent((p) => p.isObjectProperty() ||
+        p.isJSXOpeningElement() ||
+        p.isVariableDeclarator());
+    if (parent) {
+        if (parent.isVariableDeclarator()) {
+            const id = parent.get('id');
+            // FIXME: replace with id.isReferencedIdentifier()
+            if (id.isIdentifier()) {
+                const { referencePaths } = path.scope.getBinding(id.node.name) || {
+                    referencePaths: [],
+                };
+                isReferenced = referencePaths.length !== 0;
+            }
+        }
+    }
+    return isReferenced;
+}
+const counters = new WeakMap();
+const getNextIndex = (state) => {
+    const counter = counters.get(state) ?? 0;
+    counters.set(state, counter + 1);
+    return counter;
+};
+function getTagProcessor(path, fileContext, options) {
+    const cache = (0, traversalCache_1.getTraversalCache)(path, 'getTagProcessor');
+    if (!cache.has(path.node)) {
+        const root = path.scope.getProgramParent().path;
+        const { imports } = (0, collectExportsAndImports_1.collectExportsAndImports)(root);
+        try {
+            const builder = getBuilderForIdentifier(path, imports.filter(collectExportsAndImports_1.explicitImport), fileContext.filename, options);
+            if (builder) {
+                // Increment the index of the style we're processing
+                // This is used for slug generation to prevent collision
+                // Also used for display name if it couldn't be determined
+                const idx = getNextIndex(fileContext);
+                const displayName = getDisplayName(path, idx, fileContext.filename);
+                const processor = builder(displayName, isTagReferenced(path), idx, options, fileContext);
+                cache.set(path.node, processor);
+            }
+            else {
+                cache.set(path.node, null);
+            }
+        }
+        catch (e) {
+            if (e === processor_utils_1.BaseProcessor.SKIP) {
+                cache.set(path.node, null);
+                return null;
+            }
+            if (e instanceof Error) {
+                throw buildCodeFrameError(path, e.message);
+            }
+            throw e;
+        }
+    }
+    return cache.get(path.node) ?? null;
+}
+exports.getTagProcessor = getTagProcessor;

package/types/utils/getVisitorKeys.d.ts

@@ -0,0 +1,5 @@
+import type { Node } from '@babel/types';
+export type VisitorKeys<T extends Node> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends Node | Node[] | null ? K : never;
+}[keyof T] & string;
+export declare function getVisitorKeys<TNode extends Node>(node: TNode): VisitorKeys<TNode>[];

package/types/utils/getVisitorKeys.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVisitorKeys = void 0;
+const core_1 = require("@babel/core");
+function getVisitorKeys(node) {
+    return core_1.types.VISITOR_KEYS[node.type];
+}
+exports.getVisitorKeys = getVisitorKeys;

package/types/utils/hasLinariaPreval.d.ts

@@ -0,0 +1,4 @@
+import type { Value } from '@wyw-in-js/processor-utils';
+export default function hasLinariaPreval(exports: unknown): exports is {
+    __linariaPreval: Record<string, () => Value> | null | undefined;
+};

package/types/utils/hasLinariaPreval.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function hasLinariaPreval(exports) {
+    if (!exports || typeof exports !== 'object') {
+        return false;
+    }
+    return '__linariaPreval' in exports;
+}
+exports.default = hasLinariaPreval;

package/types/utils/isExports.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from '@babel/traverse';
+/**
+ * Checks that specified Identifier is a global `exports` or `module.exports`
+ * @param node
+ */
+export declare function isExports(node: NodePath | null | undefined): boolean;

package/types/utils/isExports.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExports = void 0;
+const isGlobal_1 = require("./isGlobal");
+/**
+ * Checks that specified Identifier is a global `exports` or `module.exports`
+ * @param node
+ */
+function isExports(node) {
+    if (node?.isIdentifier({ name: 'exports' })) {
+        return (0, isGlobal_1.isGlobal)(node, 'exports');
+    }
+    if (node?.isMemberExpression() &&
+        node.get('object').isIdentifier({ name: 'module' }) &&
+        node.get('property').isIdentifier({ name: 'exports' })) {
+        return (0, isGlobal_1.isGlobal)(node, 'module');
+    }
+    return false;
+}
+exports.isExports = isExports;

package/types/utils/isGlobal.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from '@babel/traverse';
+export declare const isGlobal: (node: NodePath, name: string) => boolean;

package/types/utils/isGlobal.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlobal = void 0;
+const getScope_1 = require("./getScope");
+const isGlobal = (node, name) => {
+    const scope = (0, getScope_1.getScope)(node);
+    return scope.getBinding(name) === undefined && scope.hasGlobal(name);
+};
+exports.isGlobal = isGlobal;

package/types/utils/isNode.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from '@babel/types';
+export declare const isNode: (obj: unknown) => obj is Node;

package/types/utils/isNode.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNode = void 0;
+const isNode = (obj) => typeof obj === 'object' &&
+    obj !== null &&
+    obj?.type !== undefined;
+exports.isNode = isNode;

package/types/utils/isNodePath.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/traverse';
+import type { Node } from '@babel/types';
+export declare function isNodePath<T extends Node>(obj: NodePath<T> | T): obj is NodePath<T>;

package/types/utils/isNodePath.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodePath = void 0;
+function isNodePath(obj) {
+    return 'node' in obj && obj?.node !== undefined;
+}
+exports.isNodePath = isNodePath;

package/types/utils/isNotNull.d.ts

@@ -0,0 +1 @@
+export declare function isNotNull<T>(x: T | null): x is T;

package/types/utils/isNotNull.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNull = void 0;
+function isNotNull(x) {
+    return x !== null;
+}
+exports.isNotNull = isNotNull;

package/types/utils/isRemoved.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from '@babel/traverse';
+/**
+ * Checks if a given path has been removed from the AST.
+ */
+export declare function isRemoved(path: NodePath): boolean;

package/types/utils/isRemoved.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRemoved = void 0;
+/**
+ * Checks if a given path has been removed from the AST.
+ */
+function isRemoved(path) {
+    // Check if the input path has already been removed
+    if (path.removed) {
+        return true;
+    }
+    // Check if any of the parent paths have been removed
+    let currentPath = path;
+    while (currentPath) {
+        const parent = currentPath.parentPath;
+        if (parent) {
+            // If the parent path has been removed, return true
+            if (parent.removed || parent.node === null) {
+                return true;
+            }
+            const { listKey, key, node } = currentPath;
+            if (listKey) {
+                // If the current path is part of a list and the current node
+                // is not presented in this list, return true
+                const found = parent.get(listKey).find((p) => p.node === node);
+                if (!found) {
+                    return true;
+                }
+            }
+            // If the current path is not part of a list and its node is not the same
+            // as the node in the parent object at the same key, return true
+            else if (parent.get(key).node !== node) {
+                return true;
+            }
+        }
+        // Set the current path to its parent path and continue the loop
+        currentPath = parent;
+    }
+    // If the function has not returned true by this point, return false
+    return false;
+}
+exports.isRemoved = isRemoved;

package/types/utils/isRequire.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from '@babel/traverse';
+/**
+ * Checks that specified Identifier is a global `require`
+ * @param id
+ */
+export declare function isRequire(id: NodePath | null | undefined): boolean;

package/types/utils/isRequire.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequire = void 0;
+const isGlobal_1 = require("./isGlobal");
+/**
+ * Checks that specified Identifier is a global `require`
+ * @param id
+ */
+function isRequire(id) {
+    if (!id?.isIdentifier() || id.node.name !== 'require') {
+        return false;
+    }
+    return (0, isGlobal_1.isGlobal)(id, 'require');
+}
+exports.isRequire = isRequire;

package/types/utils/isSerializable.d.ts

@@ -0,0 +1,2 @@
+import type { Serializable } from '../types';
+export declare function isSerializable(o: unknown): o is Serializable;

package/types/utils/isSerializable.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializable = void 0;
+const shared_1 = require("@wyw-in-js/shared");
+function isSerializable(o) {
+    if (Array.isArray(o)) {
+        return o.every(isSerializable);
+    }
+    if (o === null)
+        return true;
+    if ((0, shared_1.isBoxedPrimitive)(o))
+        return true;
+    if (typeof o === 'object') {
+        return Object.values(o).every(isSerializable);
+    }
+    return (typeof o === 'string' || typeof o === 'number' || typeof o === 'boolean');
+}
+exports.isSerializable = isSerializable;

package/types/utils/isTypedNode.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from '@babel/traverse';
+import type { Node } from '@babel/types';
+export declare const isTypedNode: <T extends NodePath['type']>(type: T) => (p: NodePath) => p is NodePath<Extract<Node, {
+    type: T;
+}>>;

package/types/utils/isTypedNode.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypedNode = void 0;
+const isTypedNode = (type) => {
+    return (p) => {
+        return p.type === type;
+    };
+};
+exports.isTypedNode = isTypedNode;

package/types/utils/isUnnecessaryReactCall.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/core';
+import type { CallExpression } from '@babel/types';
+export declare function isUnnecessaryReactCall(path: NodePath<CallExpression>): boolean;

package/types/utils/isUnnecessaryReactCall.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnnecessaryReactCall = void 0;
+const collectExportsAndImports_1 = require("./collectExportsAndImports");
+const getScope_1 = require("./getScope");
+function getCallee(p) {
+    const callee = p.get('callee');
+    if (callee.isSequenceExpression()) {
+        const expressions = callee.get('expressions');
+        if (expressions.length === 2 &&
+            expressions[0].isNumericLiteral({ value: 0 })) {
+            return expressions[1];
+        }
+        return callee;
+    }
+    return callee;
+}
+const JSXRuntimeSource = 'react/jsx-runtime';
+function isJSXRuntime(p, imports) {
+    const jsxRuntime = imports.find((i) => i.source === JSXRuntimeSource);
+    const jsxRuntimeName = jsxRuntime?.local?.isIdentifier() && jsxRuntime?.local?.node?.name;
+    if (jsxRuntime) {
+        const callee = getCallee(p);
+        if (jsxRuntimeName && callee.isIdentifier({ name: jsxRuntimeName })) {
+            return true;
+        }
+        if (callee.isMemberExpression() &&
+            imports.find((i) => i.source === JSXRuntimeSource && i.local === callee)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isHookOrCreateElement(name) {
+    return name === 'createElement' || /use[A-Z]/.test(name);
+}
+function isClassicReactRuntime(p, imports) {
+    const reactImports = imports.filter((i) => i.source === 'react' &&
+        (i.imported === 'default' ||
+            (i.imported && isHookOrCreateElement(i.imported))));
+    if (reactImports.length === 0)
+        return false;
+    const callee = getCallee(p);
+    if (callee.isIdentifier() && isHookOrCreateElement(callee.node.name)) {
+        const bindingPath = (0, getScope_1.getScope)(callee).getBinding(callee.node.name)?.path;
+        return reactImports.some((i) => bindingPath?.isAncestor(i.local));
+    }
+    if (callee.isMemberExpression()) {
+        if (reactImports.some((i) => i.local === callee)) {
+            // It's React.createElement in CJS
+            return true;
+        }
+        const object = callee.get('object');
+        const property = callee.get('property');
+        const defaultImport = reactImports.find((i) => i.imported === 'default');
+        if (!defaultImport ||
+            !defaultImport.local.isIdentifier() ||
+            !property.isIdentifier() ||
+            !isHookOrCreateElement(property.node.name) ||
+            !object.isIdentifier({ name: defaultImport.local.node.name })) {
+            return false;
+        }
+        const bindingPath = (0, getScope_1.getScope)(object).getBinding(object.node.name)?.path;
+        return bindingPath?.isAncestor(defaultImport.local) ?? false;
+    }
+    return false;
+}
+function isUnnecessaryReactCall(path) {
+    const programPath = path.findParent((p) => p.isProgram());
+    if (!programPath) {
+        return false;
+    }
+    const { imports } = (0, collectExportsAndImports_1.collectExportsAndImports)(programPath);
+    return isJSXRuntime(path, imports) || isClassicReactRuntime(path, imports);
+}
+exports.isUnnecessaryReactCall = isUnnecessaryReactCall;

package/types/utils/peek.d.ts

@@ -0,0 +1 @@
+export declare const peek: <T>(stack: T[], offset?: number) => T;

package/types/utils/peek.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peek = void 0;
+const peek = (stack, offset = 1) => stack[stack.length - offset];
+exports.peek = peek;

package/types/utils/processTemplateExpression.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from '@babel/traverse';
+import type { Identifier } from '@babel/types';
+import type { BaseProcessor, IFileContext } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+export declare const processTemplateExpression: (p: NodePath<Identifier>, fileContext: IFileContext, options: Pick<StrictOptions, 'classNameSlug' | 'displayName' | 'evaluate' | 'tagResolver'>, emit: (processor: BaseProcessor) => void) => void;

package/types/utils/processTemplateExpression.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTemplateExpression = void 0;
+const getTagProcessor_1 = require("./getTagProcessor");
+const processed = new WeakSet();
+const processTemplateExpression = (p, fileContext, options, emit) => {
+    if (p.parentPath.isExportSpecifier())
+        return;
+    if (processed.has(p.node))
+        return;
+    const tagProcessor = (0, getTagProcessor_1.getTagProcessor)(p, fileContext, options);
+    processed.add(p.node);
+    if (tagProcessor === null)
+        return;
+    emit(tagProcessor);
+};
+exports.processTemplateExpression = processTemplateExpression;

package/types/utils/removeDangerousCode.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/core';
+import type { Program } from '@babel/types';
+export declare const removeDangerousCode: (programPath: NodePath<Program>) => void;