@lwrjs/module-bundler 0.10.0-alpha.13 → 0.10.0-alpha.15

package/build/cjs/utils/amd-common.cjs

@@ -32,7 +32,30 @@ var import_plugin_replace = __toModule(require("@rollup/plugin-replace"));
 var import_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
 var import_bundle_common = __toModule(require("./bundle-common.cjs"));
 var AMD_DEFINE = "LWR.define";
-async function bundle(id, moduleGraphs, minify = false) {
+var groupieCodeCache = new Map();
+function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
+  return (moduleRef) => {
+    if (external[moduleRef.specifier]) {
+      return false;
+    }
+    const moduleRefIsGroupie = (0, import_shared_utils.isGroupie)(moduleRef.specifier, groups);
+    const rootModuleIsGroupie = (0, import_shared_utils.isGroupie)(graphSpecifier, groups);
+    const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
+    if (moduleRefIsGroupie) {
+      if (moduleIsNotRoot && !rootModuleIsGroupie) {
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+      }
+      return false;
+    } else if (exclude?.includes(moduleRef.specifier)) {
+      if (moduleIsNotRoot) {
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+      }
+      return false;
+    }
+    return true;
+  };
+}
+async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = false) {
   const plugins = [(0, import_rollup_amd_bundler_plugin.bundleDefinitions)({moduleGraphs})];
   minify && plugins.push((0, import_plugin_replace.default)({
     "process.env.NODE_ENV": JSON.stringify("production"),
@@ -44,35 +67,41 @@ async function bundle(id, moduleGraphs, minify = false) {
     exports: "named",
     format: "amd"
   });
-  return output[0].code;
+  let code = output[0].code;
+  if (unVersionedAliases) {
+    const idObject = (0, import_shared_utils.explodeSpecifier)(id);
+    const specifier = idObject.specifier;
+    const aliasModule = (0, import_shared_utils.createAmdAlias)(specifier, id);
+    code += aliasModule;
+  }
+  return code;
 }
-async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
-  const {exclude, external = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
-  const externalsArray = Object.keys(external);
-  const requiredImports = new Map();
-  const dynamicImports = new Map();
-  const includedModules = [];
-  const graphOptions = {
-    includeLinkedDefinitions: true,
-    depth: {
-      static: import_shared_utils.GraphDepth.ALL,
-      dynamic: 0,
-      includeId: (moduleRef) => {
-        if (externalsArray.includes(moduleRef.specifier)) {
-          return false;
-        } else if (exclude?.includes(moduleRef.specifier)) {
-          requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
-          return false;
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases, includeId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, visitedSpecifiers) {
+  const modules = [rootModule, ...moduleGraphs.graphs[0].static];
+  const {moduleRecord} = await moduleRegistry.getModule((0, import_shared_utils.explodeSpecifier)(rootModule));
+  if (moduleRecord.importMeta) {
+    for (const specifier of modules) {
+      const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+      const imports = linkedDefinition?.linkedModuleRecord.imports || [];
+      for (const imp of imports) {
+        const modId = (0, import_shared_utils.explodeSpecifier)(imp.specifier);
+        if (!modules.includes(imp.specifier) && includeId(modId)) {
+          modules.push(imp.specifier);
+          if (!moduleGraphs.linkedDefinitions[imp.specifier]) {
+            const missingLinkedModule = await moduleRegistry.getLinkedModule({specifier: modId.specifier, version: modId.version}, runtimeEnvironment, runtimeParams);
+            moduleGraphs.linkedDefinitions[imp.specifier] = missingLinkedModule;
+          }
         }
-        return true;
       }
     }
-  };
-  const moduleGraphs = await (0, import_shared_utils.getModuleGraphs)(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
-  const rootModule = moduleGraphs.graphs[0];
-  const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
-  const bundles = await Promise.all(modules.reduce((filteredModules, specifier2) => {
-    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier2];
+  }
+  const bundles = (await Promise.all(modules.reduce((filteredModules, specifier) => {
+    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+    if (visitedSpecifiers?.has(specifier)) {
+      return filteredModules;
+    } else {
+      visitedSpecifiers?.set(specifier, true);
+    }
     if (!linkedDefinition) {
       return filteredModules;
     }
@@ -81,18 +110,76 @@ async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvir
         dynamicImports.set(`${dynamicImport.specifier}_${dynamicImport.version}`, dynamicImport);
       }
     });
-    if (specifier2.includes("#")) {
+    if (specifier.includes("#")) {
       return filteredModules;
     }
     filteredModules.unshift(linkedDefinition);
     return filteredModules;
   }, []).map((linkedDefinition) => {
-    const id2 = (0, import_shared_utils.getSpecifier)(linkedDefinition);
-    if (id2 !== rootModule.specifier) {
-      includedModules.push(id2);
+    const id = (0, import_shared_utils.getSpecifier)(linkedDefinition);
+    if (id !== rootModule) {
+      includedModules.push(id);
+    } else {
+      bundleGroupsIncludedModules.push(id);
     }
-    return bundle(id2, moduleGraphs, minify);
-  }));
+    return bundle(id, moduleGraphs, minify, unVersionedAliases);
+  }))).filter(Boolean);
+  return bundles;
+}
+async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
+  const {exclude, external = {}, groups = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
+  const requiredImports = new Map();
+  const dynamicImports = new Map();
+  const groupName = (0, import_shared_utils.getGroupName)(rootModuleId.specifier, groups);
+  const groupies = groupName && groups[groupName];
+  const cachedGroupieCode = groupName && groupieCodeCache.get(groupName);
+  const getModuleGraphsWrapper = (graphSpecifier) => {
+    const graphOptions = {
+      includeLinkedDefinitions: true,
+      depth: {
+        static: import_shared_utils.GraphDepth.ALL,
+        dynamic: 0,
+        includeId: includeIdFactory(graphSpecifier, external, exclude, requiredImports, groups)
+      }
+    };
+    return (0, import_shared_utils.getModuleGraphs)(graphSpecifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
+  };
+  const moduleGraphs = await getModuleGraphsWrapper(rootModuleId.specifier);
+  const rootModule = moduleGraphs.graphs[0];
+  const groupModuleGraphsMap = new Map();
+  if (!cachedGroupieCode && groupies && groupies.length) {
+    for (const specifier2 of groupies) {
+      if (specifier2 !== rootModuleId.specifier) {
+        const groupieModuleGraph = await getModuleGraphsWrapper(specifier2);
+        groupModuleGraphsMap.set(specifier2, groupieModuleGraph);
+      }
+    }
+  }
+  let bundleCode, includedModules, bundleGroupsIncludedModules;
+  const cachedBundleGroupCode = cachedGroupieCode;
+  const bundledSpecifiersMap = new Map();
+  if (!cachedBundleGroupCode) {
+    includedModules = [], bundleGroupsIncludedModules = [];
+    const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rootModuleId.specifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+    if (groupName) {
+      for (const rawGroupieSpecifier of groupies) {
+        if (rawGroupieSpecifier !== rootModuleId.specifier) {
+          const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
+          const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
+          const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+          bundles.push(...groupieBundles);
+        }
+      }
+    }
+    bundleCode = bundles.join("");
+    if (groupName) {
+      includedModules.push(...bundleGroupsIncludedModules);
+      groupieCodeCache.set(groupName, {code: bundleCode, includedModules});
+    }
+  } else {
+    bundleCode = cachedBundleGroupCode.code;
+    includedModules = cachedBundleGroupCode.includedModules;
+  }
   const {id, name, namespace, version, specifier} = moduleGraphs.linkedDefinitions[rootModule.specifier];
   return {
     id,
@@ -100,7 +187,7 @@ async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvir
     namespace,
     version,
     specifier,
-    code: bundles.join(""),
+    code: bundleCode,
     config: {external, exclude},
     bundleRecord: {
       imports: Array.from(requiredImports.values()),

package/build/es/utils/amd-common.d.ts

@@ -1,3 +1,3 @@
 import type { AbstractModuleId, BundleConfigOverrides, BundleDefinition, ModuleRegistry, ProviderAppConfig, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
-export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, minify: boolean | undefined, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig }: ProviderAppConfig, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
+export declare function amdBundler(rootModuleId: AbstractModuleId, moduleRegistry: ModuleRegistry, minify: boolean | undefined, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig }: ProviderAppConfig, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
 //# sourceMappingURL=amd-common.d.ts.map

package/build/es/utils/amd-common.js

@@ -1,14 +1,46 @@
-import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
+import { GraphDepth, createAmdAlias, explodeSpecifier, getModuleGraphs, getSpecifier, getGroupName, isGroupie, } from '@lwrjs/shared-utils';
 import { rollup } from 'rollup';
 import replace from '@rollup/plugin-replace';
 import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
 import { overrideBundleConfig } from './bundle-common.js';
 const AMD_DEFINE = 'LWR.define';
-async function bundle(id, moduleGraphs, minify = false) {
+const groupieCodeCache = new Map();
+function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
+    return (moduleRef) => {
+        // Do not bundle externals, including the loader module, which is auto bundled
+        // with the shim + loader combo
+        if (external[moduleRef.specifier]) {
+            // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
+            return false;
+        }
+        const moduleRefIsGroupie = isGroupie(moduleRef.specifier, groups);
+        const rootModuleIsGroupie = isGroupie(graphSpecifier, groups);
+        const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
+        if (moduleRefIsGroupie) {
+            // If this is part of bundle group return false to indicate it should not be in the bundle
+            // but add it to the requriedImports so it shows up as a static dependency of the bundle.
+            // However, skip this if the requested specifier is also part of the same group.
+            if (moduleIsNotRoot && !rootModuleIsGroupie) {
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+            }
+            return false;
+        }
+        else if (exclude?.includes(moduleRef.specifier)) {
+            // If this is a bundle exclude return false to indicate it should not be in the bundle
+            // but add it to the requriedImports so it shows up as a static dependency of the bundle.
+            if (moduleIsNotRoot) {
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+            }
+            return false;
+        }
+        return true;
+    };
+}
+async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = false) {
     const plugins = [bundleDefinitions({ moduleGraphs })];
     minify &&
         plugins.push(
-        // terser(), // Do not minify until needed for client modules. Server/SSR modules do not need to be minifed.
+        // terser(), // Do not minify until needed for client modules. Server/SSR modules do not need to be minified.
         replace({
             'process.env.NODE_ENV': JSON.stringify('production'),
             preventAssignment: false,
@@ -19,42 +51,47 @@ async function bundle(id, moduleGraphs, minify = false) {
         exports: 'named',
         format: 'amd',
     });
-    return output[0].code;
+    let code = output[0].code;
+    if (unVersionedAliases) {
+        const idObject = explodeSpecifier(id);
+        const specifier = idObject.specifier;
+        const aliasModule = createAmdAlias(specifier, id);
+        code += aliasModule;
+    }
+    return code;
 }
-export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
-    const { exclude, external = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
-    const externalsArray = Object.keys(external);
-    const requiredImports = new Map();
-    const dynamicImports = new Map();
-    const includedModules = [];
-    const graphOptions = {
-        includeLinkedDefinitions: true,
-        depth: {
-            static: GraphDepth.ALL,
-            dynamic: 0,
-            includeId: (moduleRef) => {
-                // Do not bundle externals, including the loader module, which is auto bundled
-                // with the shim + loader combo
-                if (externalsArray.includes(moduleRef.specifier)) {
-                    // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
-                    return false;
-                }
-                else if (exclude?.includes(moduleRef.specifier)) {
-                    // If this is a bundle exclude return false to indicate it should not be in the bundle
-                    // but add it to the requriedImports so it shows up as a static dependency of the bundle.
-                    requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
-                    return false;
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases, includeId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, visitedSpecifiers) {
+    const modules = [rootModule, ...moduleGraphs.graphs[0].static];
+    const { moduleRecord } = await moduleRegistry.getModule(explodeSpecifier(rootModule));
+    // add static imports from the LinkedModuleDefinitions added during module linking
+    // they're not in the ModuleGraph imports b/c those are based on raw module source
+    if (moduleRecord.importMeta) {
+        // the only use case for this is "lwr/environment", so skip the logic when it's not needed
+        for (const specifier of modules) {
+            const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+            const imports = linkedDefinition?.linkedModuleRecord.imports || [];
+            for (const imp of imports) {
+                const modId = explodeSpecifier(imp.specifier);
+                if (!modules.includes(imp.specifier) && includeId(modId)) {
+                    modules.push(imp.specifier);
+                    if (!moduleGraphs.linkedDefinitions[imp.specifier]) {
+                        // eslint-disable-next-line no-await-in-loop
+                        const missingLinkedModule = await moduleRegistry.getLinkedModule({ specifier: modId.specifier, version: modId.version }, runtimeEnvironment, runtimeParams);
+                        moduleGraphs.linkedDefinitions[imp.specifier] = missingLinkedModule;
+                    }
                 }
-                return true;
-            },
-        },
-    };
-    const moduleGraphs = await getModuleGraphs(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
-    const rootModule = moduleGraphs.graphs[0];
-    const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
-    const bundles = await Promise.all(modules
+            }
+        }
+    }
+    const bundles = (await Promise.all(modules
         .reduce((filteredModules, specifier) => {
         const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+        if (visitedSpecifiers?.has(specifier)) {
+            return filteredModules;
+        }
+        else {
+            visitedSpecifiers?.set(specifier, true);
+        }
         // skip modules that do not have a linked definition
         if (!linkedDefinition) {
             return filteredModules;
@@ -75,12 +112,79 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
     }, [])
         .map((linkedDefinition) => {
         const id = getSpecifier(linkedDefinition);
-        if (id !== rootModule.specifier) {
+        if (id !== rootModule) {
             includedModules.push(id);
         }
+        else {
+            // we need to still keep track of roots for bundle groups
+            bundleGroupsIncludedModules.push(id);
+        }
         // bundle all dependencies for the linked definition and convert to AMD
-        return bundle(id, moduleGraphs, minify);
-    }));
+        return bundle(id, moduleGraphs, minify, unVersionedAliases);
+    }))).filter(Boolean);
+    return bundles;
+}
+export async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {}, groups = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
+    // Note: the maps must be cleared each time we call getModuleGraph
+    const requiredImports = new Map();
+    const dynamicImports = new Map();
+    const groupName = getGroupName(rootModuleId.specifier, groups);
+    const groupies = groupName && groups[groupName];
+    const cachedGroupieCode = groupName && groupieCodeCache.get(groupName);
+    const getModuleGraphsWrapper = (graphSpecifier) => {
+        const graphOptions = {
+            includeLinkedDefinitions: true,
+            depth: {
+                static: GraphDepth.ALL,
+                dynamic: 0,
+                includeId: includeIdFactory(graphSpecifier, external, exclude, requiredImports, groups),
+            },
+        };
+        return getModuleGraphs(graphSpecifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
+    };
+    const moduleGraphs = await getModuleGraphsWrapper(rootModuleId.specifier);
+    const rootModule = moduleGraphs.graphs[0];
+    // we also need to get moduleGraphs for any group members this module belongs to
+    const groupModuleGraphsMap = new Map();
+    if (!cachedGroupieCode && groupies && groupies.length) {
+        for (const specifier of groupies) {
+            if (specifier !== rootModuleId.specifier) {
+                // eslint-disable-next-line no-await-in-loop
+                const groupieModuleGraph = await getModuleGraphsWrapper(specifier);
+                groupModuleGraphsMap.set(specifier, groupieModuleGraph);
+            }
+        }
+    }
+    let bundleCode, includedModules, bundleGroupsIncludedModules;
+    // we don't need to recompute the bundle code if it already exists for this group
+    const cachedBundleGroupCode = cachedGroupieCode;
+    const bundledSpecifiersMap = new Map();
+    if (!cachedBundleGroupCode) {
+        (includedModules = []), (bundleGroupsIncludedModules = []);
+        const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rootModuleId.specifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+        if (groupName) {
+            // add groupies to bundles
+            for (const rawGroupieSpecifier of groupies) {
+                if (rawGroupieSpecifier !== rootModuleId.specifier) {
+                    const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
+                    const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
+                    // eslint-disable-next-line no-await-in-loop
+                    const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+                    bundles.push(...groupieBundles);
+                }
+            }
+        }
+        bundleCode = bundles.join('');
+        if (groupName) {
+            includedModules.push(...bundleGroupsIncludedModules);
+            groupieCodeCache.set(groupName, { code: bundleCode, includedModules });
+        }
+    }
+    else {
+        bundleCode = cachedBundleGroupCode.code;
+        includedModules = cachedBundleGroupCode.includedModules;
+    }
     const { id, name, namespace, version, specifier } = moduleGraphs.linkedDefinitions[rootModule.specifier];
     return {
         id,
@@ -88,7 +192,7 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
         namespace,
         version,
         specifier,
-        code: bundles.join(''),
+        code: bundleCode,
         config: { external, exclude },
         bundleRecord: {
             imports: Array.from(requiredImports.values()),

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.10.0-alpha.13",
+    "version": "0.10.0-alpha.15",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -37,7 +37,9 @@
         }
     },
     "scripts": {
-        "build": "tsc -b"
+        "build": "tsc -b",
+        "clean": "rm -rf build",
+        "test": "jest"
     },
     "files": [
         "build/**/*.js",
@@ -45,13 +47,16 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwc/features": "2.45.2",
-        "@lwrjs/shared-utils": "0.10.0-alpha.13",
+        "@lwc/features": "2.46.0",
+        "@lwrjs/shared-utils": "0.10.0-alpha.15",
         "@rollup/plugin-replace": "^2.4.2",
         "rollup": "^2.78.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.10.0-alpha.13"
+        "@lwrjs/types": "0.10.0-alpha.15",
+        "jest": "^26.6.3",
+        "ts-jest": "^26.5.6",
+        "typescript": "~4.3.5"
     },
     "optionalDependencies": {
         "esbuild": "^0.9.7"
@@ -59,5 +64,8 @@
     "engines": {
         "node": ">=16.0.0 <20"
     },
-    "gitHead": "f6d142d5a027554cb1685389e0b173734149683d"
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "gitHead": "70557f63a46167c40cf1415f12af69f78ae402d6"
 }