@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro/src/DeltaBundler/Serializers/baseJSBundle.js

@@ -0,0 +1,45 @@
+"use strict";
+const getAppendScripts = require("../../lib/getAppendScripts");
+const processModules = require("./helpers/processModules");
+function baseJSBundle(entryPoint, preModules, graph, options) {
+  for (const module2 of graph.dependencies.values()) {
+    options.createModuleId(module2.path);
+  }
+  const processModulesOptions = {
+    filter: options.processModuleFilter,
+    createModuleId: options.createModuleId,
+    dev: options.dev,
+    projectRoot: options.projectRoot
+  };
+  if (options.modulesOnly) {
+    preModules = [];
+  }
+  const preCode = processModules(preModules, processModulesOptions).map(([_, code]) => code).join("\n");
+  const modules = [...graph.dependencies.values()].sort(
+    (a, b) => options.createModuleId(a.path) - options.createModuleId(b.path)
+  );
+  const postCode = processModules(
+    getAppendScripts(entryPoint, [...preModules, ...modules], graph.importBundleNames, {
+      asyncRequireModulePath: options.asyncRequireModulePath,
+      createModuleId: options.createModuleId,
+      getRunModuleStatement: options.getRunModuleStatement,
+      inlineSourceMap: options.inlineSourceMap,
+      projectRoot: options.projectRoot,
+      runBeforeMainModule: options.runBeforeMainModule,
+      runModule: options.runModule,
+      serverRoot: options.serverRoot,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    }),
+    processModulesOptions
+  ).map(([_, code]) => code).join("\n");
+  return {
+    pre: preCode,
+    post: postCode,
+    modules: processModules([...graph.dependencies.values()], processModulesOptions).map(([module2, code]) => [
+      options.createModuleId(module2.path),
+      code
+    ])
+  };
+}
+module.exports = baseJSBundle;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getAllFiles.js

@@ -0,0 +1,30 @@
+"use strict";
+const { getAssetFiles } = require("../../Assets");
+const { getJsOutput, isJsModule } = require("./helpers/js");
+async function getAllFiles(pre, graph, options) {
+  const modules = graph.dependencies;
+  const { processModuleFilter } = options;
+  const promises = [];
+  for (const module2 of pre) {
+    if (processModuleFilter(module2)) {
+      promises.push([module2.path]);
+    }
+  }
+  for (const module2 of modules.values()) {
+    if (!isJsModule(module2) || !processModuleFilter(module2)) {
+      continue;
+    }
+    if (getJsOutput(module2).type === "js/module/asset") {
+      promises.push(getAssetFiles(module2.path, options.platform));
+    } else {
+      promises.push([module2.path]);
+    }
+  }
+  const dependencies = await Promise.all(promises);
+  const output = [];
+  for (const dependencyArray of dependencies) {
+    output.push(...dependencyArray);
+  }
+  return output;
+}
+module.exports = getAllFiles;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getAssets.js

@@ -0,0 +1,23 @@
+"use strict";
+const { getAssetData } = require("../../Assets");
+const { getJsOutput, isJsModule } = require("./helpers/js");
+const path = require("path");
+async function getAssets(dependencies, options) {
+  const promises = [];
+  const { processModuleFilter } = options;
+  for (const module2 of dependencies.values()) {
+    if (isJsModule(module2) && processModuleFilter(module2) && getJsOutput(module2).type === "js/module/asset" && path.relative(options.projectRoot, module2.path) !== "package.json") {
+      promises.push(
+        getAssetData(
+          module2.path,
+          path.relative(options.projectRoot, module2.path),
+          options.assetPlugins,
+          options.platform,
+          options.publicPath
+        )
+      );
+    }
+  }
+  return await Promise.all(promises);
+}
+module.exports = getAssets;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getExplodedSourceMap.js

@@ -0,0 +1,17 @@
+"use strict";
+const { getJsOutput, isJsModule } = require("./helpers/js");
+function getExplodedSourceMap(modules, options) {
+  const modulesToProcess = modules.filter(isJsModule).filter(options.processModuleFilter);
+  const result = [];
+  let firstLine1Based = 1;
+  for (const module2 of modulesToProcess) {
+    const { path } = module2;
+    const { lineCount, functionMap, map } = getJsOutput(module2).data;
+    result.push({ firstLine1Based, functionMap, path, map });
+    firstLine1Based += lineCount;
+  }
+  return result;
+}
+module.exports = {
+  getExplodedSourceMap
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/getRamBundleInfo.js

@@ -0,0 +1,87 @@
+"use strict";
+const { createRamBundleGroups } = require("../../Bundler/util");
+const getAppendScripts = require("../../lib/getAppendScripts");
+const getTransitiveDependencies = require("./helpers/getTransitiveDependencies");
+const { isJsModule, wrapModule } = require("./helpers/js");
+const { sourceMapObject } = require("./sourceMapObject");
+const nullthrows = require("nullthrows");
+const path = require("path");
+async function getRamBundleInfo(entryPoint, pre, graph, options) {
+  let modules = [...pre, ...graph.dependencies.values()];
+  modules = modules.concat(getAppendScripts(entryPoint, modules, graph.importBundleNames, options));
+  modules.forEach((module2) => options.createModuleId(module2.path));
+  const ramModules = modules.filter(isJsModule).filter(options.processModuleFilter).map((module2) => ({
+    id: options.createModuleId(module2.path),
+    code: wrapModule(module2, options),
+    map: sourceMapObject([module2], {
+      excludeSource: options.excludeSource,
+      processModuleFilter: options.processModuleFilter
+    }),
+    name: path.basename(module2.path),
+    sourcePath: module2.path,
+    source: module2.getSource().toString(),
+    type: nullthrows(module2.output.find(({ type }) => type.startsWith("js"))).type
+  }));
+  const { preloadedModules, ramGroups } = await _getRamOptions(
+    entryPoint,
+    {
+      dev: options.dev,
+      platform: options.platform
+    },
+    (filePath) => getTransitiveDependencies(filePath, graph),
+    options.getTransformOptions
+  );
+  const startupModules = [];
+  const lazyModules = [];
+  ramModules.forEach((module2) => {
+    if (preloadedModules.hasOwnProperty(module2.sourcePath)) {
+      startupModules.push(module2);
+      return;
+    }
+    if (module2.type.startsWith("js/script")) {
+      startupModules.push(module2);
+      return;
+    }
+    if (module2.type.startsWith("js/module")) {
+      lazyModules.push(module2);
+    }
+  });
+  const groups = createRamBundleGroups(ramGroups, lazyModules, (module2, dependenciesByPath) => {
+    const deps = getTransitiveDependencies(module2.sourcePath, graph);
+    const output = /* @__PURE__ */ new Set();
+    for (const dependency of deps) {
+      const module3 = dependenciesByPath.get(dependency);
+      if (module3) {
+        output.add(module3.id);
+      }
+    }
+    return output;
+  });
+  return {
+    getDependencies: (filePath) => getTransitiveDependencies(filePath, graph),
+    groups,
+    lazyModules,
+    startupModules
+  };
+}
+async function _getRamOptions(entryFile, options, getDependencies, getTransformOptions) {
+  if (getTransformOptions == null) {
+    return {
+      preloadedModules: {},
+      ramGroups: []
+    };
+  }
+  const { preloadedModules, ramGroups } = await getTransformOptions(
+    [entryFile],
+    { dev: options.dev, hot: true, platform: options.platform },
+    /* $FlowFixMe(>=0.99.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.99 was deployed. To see the error, delete this
+     * comment and run Flow. */
+    async (x) => Array.from(getDependencies)
+  );
+  return {
+    preloadedModules: preloadedModules || {},
+    ramGroups: ramGroups || []
+  };
+}
+module.exports = getRamBundleInfo;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/bytecode.js

@@ -0,0 +1,51 @@
+"use strict";
+const invariant = require("invariant");
+const path = require("path");
+function wrapModule(module2, options) {
+  const output = getBytecodeOutput(module2);
+  if (output.type.startsWith("bytecode/script")) {
+    return [output.data.bytecode];
+  }
+  const params = [
+    options.createModuleId(module2.path),
+    "[" + Array.from(module2.dependencies.values()).map((dependency) => options.createModuleId(dependency.absolutePath)).join(",") + "]"
+  ];
+  if (options.dev) {
+    params.push(JSON.stringify(path.relative(options.projectRoot, module2.path)));
+  }
+  const { compile } = require("metro-hermes-compiler");
+  const headerCode = `globalThis.$$METRO_D=[${params.join(",")}];`;
+  return [
+    compile(headerCode, {
+      sourceURL: module2.path + "-virtual.js"
+    }).bytecode,
+    output.data.bytecode
+  ];
+}
+function getBytecodeOutput(module2) {
+  const output = module2.output.filter(({ type }) => type.startsWith("bytecode/")).map(
+    (output2) => output2.data.bytecode instanceof Buffer ? output2 : (
+      // Re-create buffers after losing the Buffer instance when sending data over workers.
+      {
+        ...output2,
+        data: {
+          ...output2.data,
+          bytecode: Buffer.from(output2.data.bytecode.data)
+        }
+      }
+    )
+  );
+  invariant(
+    output.length === 1,
+    `Modules must have exactly one bytecode output, but ${module2.path} has ${output.length} bytecode outputs.`
+  );
+  return output[0];
+}
+function isBytecodeModule(module2) {
+  return module2.output.filter(({ type }) => type.startsWith("bytecode/")).length > 0;
+}
+module.exports = {
+  getBytecodeOutput,
+  isBytecodeModule,
+  wrapModule
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getInlineSourceMappingURL.js

@@ -0,0 +1,6 @@
+"use strict";
+function getInlineSourceMappingURL(sourceMap) {
+  const base64 = Buffer.from(sourceMap).toString("base64");
+  return `data:application/json;charset=utf-8;base64,${base64}`;
+}
+module.exports = getInlineSourceMappingURL;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+const { getJsOutput } = require("./js");
+function getSourceMapInfo(module2, options) {
+  return {
+    ...getJsOutput(module2).data,
+    path: module2.path,
+    source: options.excludeSource ? "" : getModuleSource(module2)
+  };
+}
+function getModuleSource(module2) {
+  if (getJsOutput(module2).type === "js/module/asset") {
+    return "";
+  }
+  return module2.getSource().toString();
+}
+module.exports = getSourceMapInfo;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js

@@ -0,0 +1,21 @@
+"use strict";
+function getTransitiveDependencies(path, graph) {
+  const dependencies = _getDeps(path, graph, /* @__PURE__ */ new Set());
+  dependencies.delete(path);
+  return dependencies;
+}
+function _getDeps(path, graph, deps) {
+  if (deps.has(path)) {
+    return deps;
+  }
+  const module2 = graph.dependencies.get(path);
+  if (!module2) {
+    return deps;
+  }
+  deps.add(path);
+  for (const dependency of module2.dependencies.values()) {
+    _getDeps(dependency.absolutePath, graph, deps);
+  }
+  return deps;
+}
+module.exports = getTransitiveDependencies;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/js.js

@@ -0,0 +1,43 @@
+"use strict";
+const invariant = require("invariant");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const path = require("path");
+function wrapModule(module2, options) {
+  const output = getJsOutput(module2);
+  if (output.type.startsWith("js/script")) {
+    return output.data.code;
+  }
+  const moduleId = options.createModuleId(module2.path);
+  const params = [
+    moduleId,
+    Array.from(module2.dependencies.values()).map((dependency) => options.createModuleId(dependency.absolutePath))
+  ];
+  if (options.dev) {
+    params.push(path.relative(options.projectRoot, module2.path));
+  }
+  return addParamsToDefineCall(output.data.code, ...params);
+}
+function getJsOutput(module2) {
+  const jsModules = module2.output.filter(({ type }) => type.startsWith("js/"));
+  invariant(
+    jsModules.length === 1,
+    `Modules must have exactly one JS output, but ${module2.path ?? "unknown module"} has ${jsModules.length} JS outputs.`
+  );
+  const jsOutput = jsModules[0];
+  invariant(
+    Number.isFinite(jsOutput.data.lineCount),
+    `JS output must populate lineCount, but ${module2.path ?? "unknown module"} has ${jsOutput.type} output with lineCount '${jsOutput.data.lineCount}'`
+  );
+  return jsOutput;
+}
+function isJsModule(module2) {
+  return module2.output.filter(isJsOutput).length > 0;
+}
+function isJsOutput(output) {
+  return output.type.startsWith("js/");
+}
+module.exports = {
+  getJsOutput,
+  isJsModule,
+  wrapModule
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/processBytecodeModules.js

@@ -0,0 +1,13 @@
+"use strict";
+const { isBytecodeModule, wrapModule } = require("./bytecode");
+function processBytecodeModules(modules, { filter = () => true, createModuleId, dev, projectRoot }) {
+  return [...modules].filter(isBytecodeModule).filter(filter).map((module2) => [
+    module2,
+    wrapModule(module2, {
+      createModuleId,
+      dev,
+      projectRoot
+    })
+  ]);
+}
+module.exports = processBytecodeModules;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/processModules.js

@@ -0,0 +1,13 @@
+"use strict";
+const { isJsModule, wrapModule } = require("./js");
+function processModules(modules, { filter = () => true, createModuleId, dev, projectRoot }) {
+  return [...modules].filter(isJsModule).filter(filter).map((module2) => [
+    module2,
+    wrapModule(module2, {
+      createModuleId,
+      dev,
+      projectRoot
+    })
+  ]);
+}
+module.exports = processModules;

package/dist/vendors/metro/src/DeltaBundler/Serializers/hmrJSBundle.js

@@ -0,0 +1,66 @@
+"use strict";
+const { isJsModule, wrapModule } = require("./helpers/js");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const path = require("path");
+const url = require("url");
+function generateModules(sourceModules, graph, options) {
+  const modules = [];
+  for (const module2 of sourceModules) {
+    if (isJsModule(module2)) {
+      const getURL = (extension) => {
+        options.clientUrl.pathname = path.relative(
+          options.projectRoot,
+          path.join(path.dirname(module2.path), path.basename(module2.path, path.extname(module2.path)) + "." + extension)
+        );
+        return url.format(options.clientUrl);
+      };
+      const sourceMappingURL = getURL("map");
+      const sourceURL = getURL("bundle");
+      const code = prepareModule(module2, graph, options) + `
+//# sourceMappingURL=${sourceMappingURL}
+//# sourceURL=${sourceURL}
+`;
+      modules.push({
+        module: [options.createModuleId(module2.path), code],
+        sourceMappingURL,
+        sourceURL
+      });
+    }
+  }
+  return modules;
+}
+function prepareModule(module2, graph, options) {
+  const code = wrapModule(module2, {
+    ...options,
+    dev: true
+  });
+  const inverseDependencies = getInverseDependencies(module2.path, graph);
+  const inverseDependenciesById = /* @__PURE__ */ Object.create(null);
+  Object.keys(inverseDependencies).forEach((path2) => {
+    inverseDependenciesById[options.createModuleId(path2)] = inverseDependencies[path2].map(options.createModuleId);
+  });
+  return addParamsToDefineCall(code, inverseDependenciesById);
+}
+function getInverseDependencies(path2, graph, inverseDependencies = {}) {
+  if (path2 in inverseDependencies) {
+    return inverseDependencies;
+  }
+  const module2 = graph.dependencies.get(path2);
+  if (!module2) {
+    return inverseDependencies;
+  }
+  inverseDependencies[path2] = [];
+  for (const inverse of module2.inverseDependencies) {
+    inverseDependencies[path2].push(inverse);
+    getInverseDependencies(inverse, graph, inverseDependencies);
+  }
+  return inverseDependencies;
+}
+function hmrJSBundle(delta, graph, options) {
+  return {
+    added: generateModules(delta.added.values(), graph, options),
+    modified: generateModules(delta.modified.values(), graph, options),
+    deleted: [...delta.deleted].map((path2) => options.createModuleId(path2))
+  };
+}
+module.exports = hmrJSBundle;

package/dist/vendors/metro/src/DeltaBundler/Serializers/sourceMapGenerator.js

@@ -0,0 +1,63 @@
+"use strict";
+const getSourceMapInfo = require("./helpers/getSourceMapInfo");
+const { isJsModule } = require("./helpers/js");
+const { fromRawMappings, fromRawMappingsNonBlocking } = require("metro-source-map");
+function getSourceMapInfosImpl(isBlocking, onDone, modules, options) {
+  const sourceMapInfos = [];
+  const modulesToProcess = modules.filter(isJsModule).filter(options.processModuleFilter);
+  function processNextModule() {
+    if (modulesToProcess.length === 0) {
+      return true;
+    }
+    const mod = modulesToProcess.shift();
+    const info = getSourceMapInfo(mod, {
+      excludeSource: options.excludeSource
+    });
+    sourceMapInfos.push(info);
+    return false;
+  }
+  function workLoop() {
+    const time = process.hrtime();
+    while (true) {
+      const isDone = processNextModule();
+      if (isDone) {
+        onDone(sourceMapInfos);
+        break;
+      }
+      if (!isBlocking) {
+        const diff = process.hrtime(time);
+        const NS_IN_MS = 1e6;
+        if (diff[1] > 50 * NS_IN_MS) {
+          setImmediate(workLoop);
+          break;
+        }
+      }
+    }
+  }
+  workLoop();
+}
+function sourceMapGenerator(modules, options) {
+  let sourceMapInfos;
+  getSourceMapInfosImpl(
+    true,
+    (infos) => {
+      sourceMapInfos = infos;
+    },
+    modules,
+    options
+  );
+  if (sourceMapInfos == null) {
+    throw new Error("Expected getSourceMapInfosImpl() to finish synchronously.");
+  }
+  return fromRawMappings(sourceMapInfos);
+}
+async function sourceMapGeneratorNonBlocking(modules, options) {
+  const sourceMapInfos = await new Promise((resolve) => {
+    getSourceMapInfosImpl(false, resolve, modules, options);
+  });
+  return fromRawMappingsNonBlocking(sourceMapInfos);
+}
+module.exports = {
+  sourceMapGenerator,
+  sourceMapGeneratorNonBlocking
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/sourceMapObject.js

@@ -0,0 +1,18 @@
+"use strict";
+const { sourceMapGenerator, sourceMapGeneratorNonBlocking } = require("./sourceMapGenerator");
+function sourceMapObject(modules, options) {
+  const generator = sourceMapGenerator(modules, options);
+  return generator.toMap(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+async function sourceMapObjectNonBlocking(modules, options) {
+  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  return generator.toMap(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+module.exports = {
+  sourceMapObject,
+  sourceMapObjectNonBlocking
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/sourceMapString.js

@@ -0,0 +1,8 @@
+"use strict";
+const { sourceMapGenerator } = require("./sourceMapGenerator");
+function sourceMapString(modules, options) {
+  return sourceMapGenerator(modules, options).toString(void 0, {
+    excludeSource: options.excludeSource
+  });
+}
+module.exports = sourceMapString;

package/dist/vendors/metro/src/DeltaBundler/Transformer.js

@@ -0,0 +1,133 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_crypto = __toESM(require("crypto"));
+const getTransformCacheKey = require("./getTransformCacheKey");
+const WorkerFarm = require("./WorkerFarm");
+const assert = require("assert");
+const fs = require("fs");
+const { Cache, stableHash } = require("metro-cache");
+const path = require("path");
+class Transformer {
+  _config;
+  _cache;
+  _baseHash;
+  _getSha1;
+  _workerFarm;
+  constructor(config, getSha1Fn) {
+    this._config = config;
+    this._config.watchFolders.forEach(verifyRootExists);
+    this._cache = new Cache(config.cacheStores);
+    this._getSha1 = getSha1Fn;
+    const {
+      getTransformOptions: _getTransformOptions,
+      transformVariants: _transformVariants,
+      workerPath: _workerPath,
+      ...transformerConfig
+    } = this._config.transformer;
+    const transformerOptions = {
+      transformerPath: this._config.transformerPath,
+      transformerConfig
+    };
+    this._workerFarm = new WorkerFarm(config, transformerOptions);
+    const globalCacheKey = this._cache.isDisabled ? "" : getTransformCacheKey({
+      cacheVersion: this._config.cacheVersion,
+      projectRoot: this._config.projectRoot,
+      transformerConfig: transformerOptions
+    });
+    this._baseHash = stableHash([globalCacheKey]).toString("binary");
+  }
+  async transformFile(filePath, transformerOptions, fileBuffer) {
+    const cache = this._cache;
+    const {
+      customTransformOptions,
+      dev,
+      experimentalImportSupport,
+      hot,
+      inlinePlatform,
+      inlineRequires,
+      minify,
+      nonInlinedRequires,
+      platform,
+      runtimeBytecodeVersion,
+      type,
+      unstable_disableES6Transforms,
+      unstable_transformProfile,
+      ...extra
+    } = transformerOptions;
+    for (const key in extra) {
+      if (hasOwnProperty.call(extra, key)) {
+        throw new Error("Extra keys detected: " + Object.keys(extra).join(", "));
+      }
+    }
+    const localPath = path.relative(this._config.projectRoot, filePath);
+    const partialKey = stableHash([
+      // This is the hash related to the global Bundler config.
+      this._baseHash,
+      // Path.
+      localPath,
+      customTransformOptions,
+      dev,
+      experimentalImportSupport,
+      hot,
+      inlinePlatform,
+      inlineRequires,
+      minify,
+      nonInlinedRequires,
+      platform,
+      runtimeBytecodeVersion,
+      type,
+      unstable_disableES6Transforms,
+      unstable_transformProfile
+    ]);
+    let sha1;
+    if (fileBuffer) {
+      sha1 = import_crypto.default.createHash("sha1").update(fileBuffer).digest("hex");
+    } else {
+      sha1 = this._getSha1(filePath);
+    }
+    let fullKey = Buffer.concat([partialKey, Buffer.from(sha1, "hex")]);
+    const result = await cache.get(fullKey);
+    const data = result ? { result, sha1 } : await this._workerFarm.transform(localPath, transformerOptions, fileBuffer);
+    if (sha1 !== data.sha1) {
+      fullKey = Buffer.concat([partialKey, Buffer.from(data.sha1, "hex")]);
+    }
+    cache.set(fullKey, data.result);
+    return {
+      ...data.result,
+      getSource() {
+        if (fileBuffer) {
+          return fileBuffer;
+        }
+        return fs.readFileSync(filePath);
+      }
+    };
+  }
+  end() {
+    this._workerFarm.kill();
+  }
+}
+function verifyRootExists(root) {
+  assert(fs.statSync(root).isDirectory(), "Root has to be a valid directory");
+}
+module.exports = Transformer;