@atlaspack/babel-plugin-transform-contextual-imports 2.14.1-canary.40 → 2.14.1-canary.401

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @atlaspack/babel-plugin-transform-contextual-imports
 
+## 2.16.2
+
+### Patch Changes
+
+- [#861](https://github.com/atlassian-labs/atlaspack/pull/861) [`ca42992`](https://github.com/atlassian-labs/atlaspack/commit/ca429925dab731600c2decd571b5245d361ca953) Thanks [@at-nathan](https://github.com/at-nathan)! - Ignore transform on type references
+
+## 2.16.1
+
+### Patch Changes
+
+- [#843](https://github.com/atlassian-labs/atlaspack/pull/843) [`f97acf2`](https://github.com/atlassian-labs/atlaspack/commit/f97acf242ed210841db3403d3a5f224f5eff5ab5) Thanks [@nickrobson](https://github.com/nickrobson)! - Transform importCond in JSX, ungate binding-based transform
+
+## 2.16.0
+
+### Minor Changes
+
+- [#795](https://github.com/atlassian-labs/atlaspack/pull/795) [`336eb1e`](https://github.com/atlassian-labs/atlaspack/commit/336eb1ef59542b7488991ff13da815f87c26645c) Thanks [@JakeLane](https://github.com/JakeLane)! - Fix binding replacement behaviour for contextual imports babel plugin
+
+## 2.15.3
+
+### Patch Changes
+
+- [#785](https://github.com/atlassian-labs/atlaspack/pull/785) [`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922) Thanks [@matt-koko](https://github.com/matt-koko)! - We need to re-publish every package in Atlaspack with the corrected types field.
+
+## 2.15.2
+
+### Patch Changes
+
+- [#742](https://github.com/atlassian-labs/atlaspack/pull/742) [`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd) Thanks [@yamadapc](https://github.com/yamadapc)! - Internal changes and bug fixes to environmentDeduplication flag
+
+## 2.15.1
+
+### Patch Changes
+
+- [#720](https://github.com/atlassian-labs/atlaspack/pull/720) [`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94) Thanks [@alshdavid](https://github.com/alshdavid)! - Migrate to TypeScript
+
+## 2.15.0
+
+### Minor Changes
+
+- [#640](https://github.com/atlassian-labs/atlaspack/pull/640) [`dbb4072`](https://github.com/atlassian-labs/atlaspack/commit/dbb40721ebeb45990a14ba04e6b44e7f836fb32d) Thanks [@JakeLane](https://github.com/JakeLane)! - Clean up conditional bundling feature flags
+
+### Patch Changes
+
+- [#682](https://github.com/atlassian-labs/atlaspack/pull/682) [`a5ed1b4`](https://github.com/atlassian-labs/atlaspack/commit/a5ed1b414498560f393ff491af4da25b6e8dde56) Thanks [@alshdavid](https://github.com/alshdavid)! - Updating build system
+
 ## 2.14.1
 
 ### Patch Changes

package/dist/index.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helper_plugin_utils_1 = require("@babel/helper-plugin-utils");
+const isNode = (opts) => !!('node' in opts && opts.node);
+exports.default = (0, helper_plugin_utils_1.declare)((api) => {
+    const { types: t } = api;
+    const isImportCondCallExpression = (node) => {
+        if (node.type === 'CallExpression' &&
+            node.callee.type === 'Identifier' &&
+            node.callee.name === 'importCond') {
+            if (node.arguments.length === 3 &&
+                node.arguments.every((arg) => arg.type === 'StringLiteral')) {
+                return true;
+            }
+            else {
+                // Simple error for incorrect syntax (since it's documented with the type)
+                throw new Error('importCond must have three string literal arguments');
+            }
+        }
+        return false;
+    };
+    const buildCondFunction = (cond, ifTrue, ifFalse) => t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default')), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')));
+    const buildNodeObject = (identifier, cond, ifTrue, ifFalse) => [
+        // Create object containing imports
+        t.variableDeclaration('const', [
+            t.variableDeclarator(identifier, t.objectExpression([
+                t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default'))),
+                t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default'))),
+            ])),
+        ]),
+        // Create lazy getter via the load property on the object.
+        // This is node module resolution safe because each time the import is accessed, we re-evaluate the condition.
+        t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [
+            identifier,
+            t.stringLiteral('load'),
+            t.objectExpression([
+                t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(identifier, t.identifier('ifTrue')), t.memberExpression(identifier, t.identifier('ifFalse'))))),
+            ]),
+        ])),
+    ];
+    return {
+        name: '@atlaspack/babel-plugin-transform-contextual-imports',
+        visitor: {
+            CallExpression: {
+                enter(path, state) {
+                    const node = path.node;
+                    if (isImportCondCallExpression(node)) {
+                        const [cond, ifTrue, ifFalse] = node.arguments;
+                        if (!isNode(state.opts)) {
+                            // Replace the importCond call with a conditional require import, as a fallback for environments that don't support Atlaspack
+                            path.replaceWith(buildCondFunction(cond, ifTrue, ifFalse));
+                        }
+                    }
+                },
+            },
+            VariableDeclaration: {
+                enter(path, state) {
+                    if (isNode(state.opts)) {
+                        if (path.node.declarations.length === 1 &&
+                            path.node.declarations[0].type === 'VariableDeclarator' &&
+                            path.node.declarations[0].id.type === 'Identifier') {
+                            const importId = path.node.declarations[0].id;
+                            const call = path.node.declarations[0].init;
+                            // Mark identifier for object so we don't add the load property to it
+                            state.visitedIdentifiers?.add(importId);
+                            if (call && isImportCondCallExpression(call)) {
+                                const [cond, ifTrue, ifFalse] = call.arguments;
+                                // Replace with object containing imports and lazy getter, which allows us to load the correct import based on the condition at runtime
+                                path.replaceWithMultiple(buildNodeObject(importId, cond, ifTrue, ifFalse));
+                                // Add the binding to set so we can mutate all references to this binding in the exit pass
+                                const binding = path.scope.getBinding(importId.name);
+                                if (binding) {
+                                    state.conditionalImportBindings?.add(binding);
+                                }
+                            }
+                        }
+                    }
+                },
+            },
+            ReferencedIdentifier: {
+                exit(path, state) {
+                    if (!isNode(state.opts)) {
+                        return;
+                    }
+                    if (path.parentPath.isTSType()) {
+                        return;
+                    }
+                    if (state.visitedIdentifiers?.has(path.node)) {
+                        return;
+                    }
+                    const binding = path.scope.getBinding(path.node.name);
+                    if (binding && state.conditionalImportBindings?.has(binding)) {
+                        if (path.isJSXIdentifier()) {
+                            // Add load property to the import usage
+                            const newIdentifer = t.jsxIdentifier(path.node.name);
+                            path.replaceWith(t.jsxMemberExpression(newIdentifer, t.jsxIdentifier('load')));
+                            state.visitedIdentifiers?.add(newIdentifer);
+                        }
+                        else {
+                            // Add load property to the import usage
+                            const newIdentifer = t.identifier(path.node.name);
+                            path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
+                            state.visitedIdentifiers?.add(newIdentifer);
+                        }
+                    }
+                },
+            },
+            Program: {
+                enter(_, state) {
+                    state.conditionalImportBindings = new Set();
+                    state.visitedIdentifiers = new Set();
+                },
+            },
+        },
+    };
+});

package/lib/index.js

@@ -1,159 +1,117 @@
-var $b65XQ$babelhelperpluginutils = require("@babel/helper-plugin-utils");
+"use strict";
 
-
-function $parcel$defineInteropFlag(a) {
-  Object.defineProperty(a, '__esModule', {value: true, configurable: true});
-}
-
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+  _helperPluginUtils = function () {
+    return data;
+  };
+  return data;
 }
+const isNode = opts => !!('node' in opts && opts.node);
+var _default = exports.default = (0, _helperPluginUtils().declare)(api => {
+  const {
+    types: t
+  } = api;
+  const isImportCondCallExpression = node => {
+    if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'importCond') {
+      if (node.arguments.length === 3 && node.arguments.every(arg => arg.type === 'StringLiteral')) {
+        return true;
+      } else {
+        // Simple error for incorrect syntax (since it's documented with the type)
+        throw new Error('importCond must have three string literal arguments');
+      }
+    }
+    return false;
+  };
+  const buildCondFunction = (cond, ifTrue, ifFalse) => t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default')), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')));
+  const buildNodeObject = (identifier, cond, ifTrue, ifFalse) => [
+  // Create object containing imports
+  t.variableDeclaration('const', [t.variableDeclarator(identifier, t.objectExpression([t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [ifTrue]), t.identifier('default'))), t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [ifFalse]), t.identifier('default')))]))]),
+  // Create lazy getter via the load property on the object.
+  // This is node module resolution safe because each time the import is accessed, we re-evaluate the condition.
+  t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [identifier, t.stringLiteral('load'), t.objectExpression([t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [cond])), t.memberExpression(identifier, t.identifier('ifTrue')), t.memberExpression(identifier, t.identifier('ifFalse')))))])]))];
+  return {
+    name: '@atlaspack/babel-plugin-transform-contextual-imports',
+    visitor: {
+      CallExpression: {
+        enter(path, state) {
+          const node = path.node;
+          if (isImportCondCallExpression(node)) {
+            const [cond, ifTrue, ifFalse] = node.arguments;
+            if (!isNode(state.opts)) {
+              // Replace the importCond call with a conditional require import, as a fallback for environments that don't support Atlaspack
+              path.replaceWith(buildCondFunction(cond, ifTrue, ifFalse));
+            }
+          }
+        }
+      },
+      VariableDeclaration: {
+        enter(path, state) {
+          if (isNode(state.opts)) {
+            if (path.node.declarations.length === 1 && path.node.declarations[0].type === 'VariableDeclarator' && path.node.declarations[0].id.type === 'Identifier') {
+              var _state$visitedIdentif;
+              const importId = path.node.declarations[0].id;
+              const call = path.node.declarations[0].init;
 
-$parcel$defineInteropFlag(module.exports);
+              // Mark identifier for object so we don't add the load property to it
+              (_state$visitedIdentif = state.visitedIdentifiers) === null || _state$visitedIdentif === void 0 || _state$visitedIdentif.add(importId);
+              if (call && isImportCondCallExpression(call)) {
+                const [cond, ifTrue, ifFalse] = call.arguments;
 
-$parcel$export(module.exports, "default", () => $35f0bedee55d5f76$export$2e2bcd8739ae039);
+                // Replace with object containing imports and lazy getter, which allows us to load the correct import based on the condition at runtime
+                path.replaceWithMultiple(buildNodeObject(importId, cond, ifTrue, ifFalse));
 
-const $35f0bedee55d5f76$var$isServer = (opts)=>{
-    return 'server' in opts && opts.server;
-};
-const $35f0bedee55d5f76$var$isNode = (opts)=>!!('node' in opts && opts.node);
-var $35f0bedee55d5f76$export$2e2bcd8739ae039 = (0, $b65XQ$babelhelperpluginutils.declare)((api)=>{
-    const { types: t } = api;
-    const isImportCondCallExpression = (node)=>{
-        if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'importCond') {
-            if (node.arguments.length === 3 && node.arguments.every((arg)=>arg.type === 'StringLiteral')) return true;
-            else // Simple error for incorrect syntax (since it's documented with the type)
-            throw new Error('importCond must have three string literal arguments');
-        }
-        return false;
-    };
-    const buildCondFunction = (cond, ifTrue, ifFalse)=>t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [
-            cond
-        ])), t.memberExpression(t.callExpression(t.identifier('require'), [
-            ifTrue
-        ]), t.identifier('default')), t.memberExpression(t.callExpression(t.identifier('require'), [
-            ifFalse
-        ]), t.identifier('default')));
-    const buildNodeObject = (identifier, cond, ifTrue, ifFalse)=>[
-            // Create object containing imports
-            t.variableDeclaration('const', [
-                t.variableDeclarator(identifier, t.objectExpression([
-                    t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [
-                        ifTrue
-                    ]), t.identifier('default'))),
-                    t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [
-                        ifFalse
-                    ]), t.identifier('default')))
-                ]))
-            ]),
-            // Create lazy getter via the load property on the object.
-            // This is node module resolution safe because each time the import is accessed, we re-evaluate the condition.
-            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [
-                identifier,
-                t.stringLiteral('load'),
-                t.objectExpression([
-                    t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [
-                        cond
-                    ])), t.memberExpression(identifier, t.identifier('ifTrue')), t.memberExpression(identifier, t.identifier('ifFalse')))))
-                ])
-            ]))
-        ];
-    const buildServerObject = (identUid, cond, ifTrue, ifFalse)=>[
-            // Create object containing imports
-            t.variableDeclaration('const', [
-                t.variableDeclarator(t.identifier(identUid), t.objectExpression([
-                    t.objectProperty(t.identifier('ifTrue'), t.memberExpression(t.callExpression(t.identifier('require'), [
-                        ifTrue
-                    ]), t.identifier('default'))),
-                    t.objectProperty(t.identifier('ifFalse'), t.memberExpression(t.callExpression(t.identifier('require'), [
-                        ifFalse
-                    ]), t.identifier('default')))
-                ]))
-            ]),
-            // Create lazy getter via the load property on the object
-            t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [
-                t.identifier(identUid),
-                t.stringLiteral('load'),
-                t.objectExpression([
-                    t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([], t.conditionalExpression(t.logicalExpression('&&', t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), t.callExpression(t.memberExpression(t.identifier('globalThis'), t.identifier('__MCOND')), [
-                        cond
-                    ])), t.memberExpression(t.identifier(identUid), t.identifier('ifTrue')), t.memberExpression(t.identifier(identUid), t.identifier('ifFalse')))))
-                ])
-            ]))
-        ];
-    const checkIsServer = (path, state)=>{
-        if (path.node.callee.type === 'Identifier' && path.node.callee.name === 'importCond') {
-            if (path.node.arguments.length == 3 && path.node.arguments.every((arg)=>arg.type === 'StringLiteral')) {
-                const [cond, ifTrue, ifFalse] = path.node.arguments;
-                if ($35f0bedee55d5f76$var$isServer(state.opts)) {
-                    // Make module pass lazy in ssr
-                    const identUid = path.scope.generateUid(`${cond.value}$${ifTrue.value}$${ifFalse.value}`);
-                    state.importNodes ??= [];
-                    state.importNodes.push(...buildServerObject(identUid, cond, ifTrue, ifFalse));
-                    // Replace call expression with reference to lazy object getter
-                    path.replaceWith(t.memberExpression(t.identifier(identUid), t.identifier('load')));
+                // Add the binding to set so we can mutate all references to this binding in the exit pass
+                const binding = path.scope.getBinding(importId.name);
+                if (binding) {
+                  var _state$conditionalImp;
+                  (_state$conditionalImp = state.conditionalImportBindings) === null || _state$conditionalImp === void 0 || _state$conditionalImp.add(binding);
                 }
+              }
             }
+          }
         }
-    };
-    return {
-        name: '@atlaspack/babel-plugin-transform-contextual-imports',
-        visitor: {
-            CallExpression: {
-                enter (path, state) {
-                    // Preserve server behaviour in deletable code
-                    checkIsServer(path, state);
-                    const node = path.node;
-                    if (isImportCondCallExpression(node)) {
-                        const [cond, ifTrue, ifFalse] = node.arguments;
-                        if (!$35f0bedee55d5f76$var$isNode(state.opts)) // Replace the importCond call with a conditional require import, as a fallback for environments that don't support Atlaspack
-                        path.replaceWith(buildCondFunction(cond, ifTrue, ifFalse));
-                    }
-                }
-            },
-            VariableDeclaration: {
-                enter (path, state) {
-                    if ($35f0bedee55d5f76$var$isNode(state.opts)) {
-                        if (path.node.declarations.length === 1 && path.node.declarations[0].type === 'VariableDeclarator' && path.node.declarations[0].id.type === 'Identifier') {
-                            const importId = path.node.declarations[0].id;
-                            const call = path.node.declarations[0].init;
-                            // Mark identifier for object so we don't add the load property to it
-                            state.visitedIdentifiers?.add(importId);
-                            if (call && isImportCondCallExpression(call)) {
-                                const [cond, ifTrue, ifFalse] = call.arguments;
-                                // Replace with object containing imports and lazy getter, which allows us to load the correct import based on the condition at runtime
-                                path.replaceWithMultiple(buildNodeObject(importId, cond, ifTrue, ifFalse));
-                                // Add identifier name to set so we can mutate all import usages in the exit pass
-                                state.conditionalImportIdentifiers?.add(importId.name);
-                            }
-                        }
-                    }
-                }
-            },
-            Identifier: {
-                exit (path, state) {
-                    const identifier = state.conditionalImportIdentifiers?.has(path.node.name);
-                    if (identifier && !state.visitedIdentifiers?.has(path.node)) {
-                        // Add load property to the import usage
-                        const newIdentifer = t.identifier(path.node.name);
-                        path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
-                        state.visitedIdentifiers?.add(newIdentifer);
-                    }
-                }
-            },
-            Program: {
-                enter (_, state) {
-                    state.conditionalImportIdentifiers = new Set();
-                    state.visitedIdentifiers = new Set();
-                },
-                exit (path, state) {
-                    if (state.importNodes) // If there's an import node, add it to the top of the body
-                    path.unshiftContainer('body', state.importNodes);
-                }
+      },
+      ReferencedIdentifier: {
+        exit(path, state) {
+          var _state$visitedIdentif2, _state$conditionalImp2;
+          if (!isNode(state.opts)) {
+            return;
+          }
+          if (path.parentPath.isTSType()) {
+            return;
+          }
+          if ((_state$visitedIdentif2 = state.visitedIdentifiers) !== null && _state$visitedIdentif2 !== void 0 && _state$visitedIdentif2.has(path.node)) {
+            return;
+          }
+          const binding = path.scope.getBinding(path.node.name);
+          if (binding && (_state$conditionalImp2 = state.conditionalImportBindings) !== null && _state$conditionalImp2 !== void 0 && _state$conditionalImp2.has(binding)) {
+            if (path.isJSXIdentifier()) {
+              var _state$visitedIdentif3;
+              // Add load property to the import usage
+              const newIdentifer = t.jsxIdentifier(path.node.name);
+              path.replaceWith(t.jsxMemberExpression(newIdentifer, t.jsxIdentifier('load')));
+              (_state$visitedIdentif3 = state.visitedIdentifiers) === null || _state$visitedIdentif3 === void 0 || _state$visitedIdentif3.add(newIdentifer);
+            } else {
+              var _state$visitedIdentif4;
+              // Add load property to the import usage
+              const newIdentifer = t.identifier(path.node.name);
+              path.replaceWith(t.memberExpression(newIdentifer, t.identifier('load')));
+              (_state$visitedIdentif4 = state.visitedIdentifiers) === null || _state$visitedIdentif4 === void 0 || _state$visitedIdentif4.add(newIdentifer);
             }
+          }
         }
-    };
-});
-
-
-//# sourceMappingURL=index.js.map
+      },
+      Program: {
+        enter(_, state) {
+          state.conditionalImportBindings = new Set();
+          state.visitedIdentifiers = new Set();
+        }
+      }
+    }
+  };
+});

package/lib/types/index.d.ts

@@ -0,0 +1,16 @@
+import type { PluginObj, types as BabelTypes } from '@babel/core';
+import type { Binding } from '@babel/traverse';
+interface Opts {
+    /** Use node safe import cond syntax */
+    node?: boolean;
+}
+interface State {
+    /** Plugin options */
+    opts: Opts;
+    /** Set of bindings that need to be mutated after import was transformed */
+    conditionalImportBindings?: Set<Binding>;
+    /** Set of identifiers that have been visited in the exit pass, to avoid adding the load property multiple times */
+    visitedIdentifiers?: Set<BabelTypes.Identifier | BabelTypes.JSXIdentifier>;
+}
+declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => PluginObj<State>;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/babel-plugin-transform-contextual-imports",
-  "version": "2.14.1-canary.40+d02eab95e",
+  "version": "2.14.1-canary.401+340caf69a",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -11,6 +11,7 @@
   },
   "main": "./lib/index.js",
   "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -23,5 +24,8 @@
     "@types/babel__helper-plugin-utils": "^7.10.3"
   },
   "type": "commonjs",
-  "gitHead": "d02eab95eb60bf7457e0869af0b773608592c0e6"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "340caf69a4143bbea119745e2e29a3516d44d522"
+}