@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/ModuleGraph/worker/collectDependencies.js

@@ -0,0 +1,440 @@
+"use strict";
+const crypto = require("crypto");
+const generate = require("@babel/generator").default;
+const template = require("@babel/template").default;
+const traverse = require("@babel/traverse").default;
+const types = require("@babel/types");
+const invariant = require("invariant");
+const nullthrows = require("nullthrows");
+const { isImport } = types;
+function collectDependencies(ast, options) {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const state = {
+    asyncRequireModulePathStringLiteral: null,
+    dependencyCalls: /* @__PURE__ */ new Set(),
+    dependencyRegistry: options.dependencyRegistry ?? new DefaultModuleDependencyRegistry(),
+    dependencyTransformer: options.dependencyTransformer ?? DefaultDependencyTransformer,
+    dependencyMapIdentifier: null,
+    dynamicRequires: options.dynamicRequires,
+    keepRequireNames: options.keepRequireNames,
+    allowOptionalDependencies: options.allowOptionalDependencies,
+    unstable_allowRequireContext: options.unstable_allowRequireContext
+  };
+  const visitor = {
+    CallExpression(path, state2) {
+      if (visited.has(path.node)) {
+        return;
+      }
+      const callee = path.node.callee;
+      const name = callee.type === "Identifier" ? callee.name : null;
+      if (isImport(callee)) {
+        processImportCall(path, state2, {
+          asyncType: "async"
+        });
+        return;
+      }
+      if (name === "__prefetchImport" && !path.scope.getBinding(name)) {
+        processImportCall(path, state2, {
+          asyncType: "prefetch"
+        });
+        return;
+      }
+      if (name === "__jsResource" && !path.scope.getBinding(name)) {
+        processImportCall(path, state2, {
+          asyncType: "async",
+          jsResource: true
+        });
+        return;
+      }
+      if (name === "__conditionallySplitJSResource" && !path.scope.getBinding(name)) {
+        const args = path.get("arguments");
+        invariant(Array.isArray(args), "Expected arguments to be an array");
+        processImportCall(path, state2, {
+          asyncType: "async",
+          jsResource: true,
+          splitCondition: args[1]
+        });
+        return;
+      }
+      if (
+        // Feature gate, defaults to `false`.
+        state2.unstable_allowRequireContext && callee.type === "MemberExpression" && // `require`
+        callee.object.type === "Identifier" && callee.object.name === "require" && // `context`
+        callee.property.type === "Identifier" && callee.property.name === "context" && !callee.computed && // Ensure `require` refers to the global and not something else.
+        !path.scope.getBinding("require")
+      ) {
+        processRequireContextCall(path, state2);
+        visited.add(path.node);
+        return;
+      }
+      if (name != null && state2.dependencyCalls.has(name) && !path.scope.getBinding(name)) {
+        processRequireCall(path, state2);
+        visited.add(path.node);
+      }
+    },
+    ImportDeclaration: collectImports,
+    ExportNamedDeclaration: collectImports,
+    ExportAllDeclaration: collectImports,
+    Program(path, state2) {
+      state2.asyncRequireModulePathStringLiteral = types.stringLiteral(options.asyncRequireModulePath);
+      if (options.dependencyMapName != null) {
+        state2.dependencyMapIdentifier = types.identifier(options.dependencyMapName);
+      } else {
+        state2.dependencyMapIdentifier = path.scope.generateUidIdentifier("dependencyMap");
+      }
+      state2.dependencyCalls = /* @__PURE__ */ new Set(["require", ...options.inlineableCalls]);
+    }
+  };
+  traverse(ast, visitor, null, state);
+  const collectedDependencies = state.dependencyRegistry.getDependencies();
+  const dependencies = new Array(collectedDependencies.length);
+  for (const { index, name, ...dependencyData } of collectedDependencies) {
+    dependencies[index] = {
+      name,
+      data: dependencyData
+    };
+  }
+  return {
+    ast,
+    dependencies,
+    dependencyMapName: nullthrows(state.dependencyMapIdentifier).name
+  };
+}
+function getRequireContextArgs(path) {
+  const args = path.get("arguments");
+  let directory;
+  if (!Array.isArray(args) || args.length < 1) {
+    throw new InvalidRequireCallError(path);
+  } else {
+    const result = args[0].evaluate();
+    if (result.confident && typeof result.value === "string") {
+      directory = result.value;
+    } else {
+      throw new InvalidRequireCallError(
+        result.deopt ?? args[0],
+        "First argument of `require.context` should be a string denoting the directory to require."
+      );
+    }
+  }
+  let recursive = true;
+  if (args.length > 1) {
+    const result = args[1].evaluate();
+    if (result.confident && typeof result.value === "boolean") {
+      recursive = result.value;
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      throw new InvalidRequireCallError(
+        result.deopt ?? args[1],
+        "Second argument of `require.context` should be an optional boolean indicating if files should be imported recursively or not."
+      );
+    }
+  }
+  let filter = { pattern: ".*", flags: "" };
+  if (args.length > 2) {
+    const result = args[2].evaluate();
+    const argNode = args[2].node;
+    if (argNode.type === "RegExpLiteral") {
+      filter = {
+        pattern: argNode.pattern,
+        flags: argNode.flags || ""
+      };
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      throw new InvalidRequireCallError(
+        args[2],
+        `Third argument of \`require.context\` should be an optional RegExp pattern matching all of the files to import, instead found node of type: ${argNode.type}.`
+      );
+    }
+  }
+  let mode = "sync";
+  if (args.length > 3) {
+    const result = args[3].evaluate();
+    if (result.confident && typeof result.value === "string") {
+      mode = getContextMode(args[3], result.value);
+    } else if (!(result.confident && typeof result.value === "undefined")) {
+      throw new InvalidRequireCallError(
+        result.deopt ?? args[3],
+        'Fourth argument of `require.context` should be an optional string "mode" denoting how the modules will be resolved.'
+      );
+    }
+  }
+  if (args.length > 4) {
+    throw new InvalidRequireCallError(
+      path,
+      `Too many arguments provided to \`require.context\` call. Expected 4, got: ${args.length}`
+    );
+  }
+  return [
+    directory,
+    {
+      recursive,
+      filter,
+      mode
+    }
+  ];
+}
+function getContextMode(path, mode) {
+  if (mode === "sync" || mode === "eager" || mode === "lazy" || mode === "lazy-once") {
+    return mode;
+  }
+  throw new InvalidRequireCallError(
+    path,
+    `require.context "${mode}" mode is not supported. Expected one of: sync, eager, lazy, lazy-once`
+  );
+}
+function processRequireContextCall(path, state) {
+  const [directory, contextParams] = getRequireContextArgs(path);
+  const transformer = state.dependencyTransformer;
+  const dep = registerDependency(
+    state,
+    {
+      // We basically want to "import" every file in a folder and then filter them out with the given `filter` RegExp.
+      name: directory,
+      // Capture the matching context
+      contextParams,
+      asyncType: null,
+      optional: isOptionalDependency(directory, path, state)
+    },
+    path
+  );
+  path.get("callee").replaceWith(types.identifier("require"));
+  transformer.transformSyncRequire(path, dep, state);
+}
+function collectImports(path, state) {
+  if (path.node.source) {
+    registerDependency(
+      state,
+      {
+        name: path.node.source.value,
+        asyncType: null,
+        optional: false
+      },
+      path
+    );
+  }
+}
+function processImportCall(path, state, options) {
+  const name = getModuleNameFromCallArgs(path);
+  if (name == null) {
+    throw new InvalidRequireCallError(path);
+  }
+  const dep = registerDependency(
+    state,
+    {
+      name,
+      asyncType: options.asyncType,
+      splitCondition: options.splitCondition,
+      optional: isOptionalDependency(name, path, state)
+    },
+    path
+  );
+  const transformer = state.dependencyTransformer;
+  if (options.jsResource) {
+    transformer.transformJSResource(path, dep, state);
+  } else if (options.asyncType === "async") {
+    transformer.transformImportCall(path, dep, state);
+  } else {
+    transformer.transformPrefetch(path, dep, state);
+  }
+}
+function processRequireCall(path, state) {
+  const name = getModuleNameFromCallArgs(path);
+  const transformer = state.dependencyTransformer;
+  if (name == null) {
+    if (state.dynamicRequires === "reject") {
+      throw new InvalidRequireCallError(path);
+    }
+    transformer.transformIllegalDynamicRequire(path, state);
+    return;
+  }
+  const dep = registerDependency(
+    state,
+    {
+      name,
+      asyncType: null,
+      optional: isOptionalDependency(name, path, state)
+    },
+    path
+  );
+  transformer.transformSyncRequire(path, dep, state);
+}
+function getNearestLocFromPath(path) {
+  let current = path;
+  while (current && !current.node.loc) {
+    current = current.parentPath;
+  }
+  return current?.node.loc;
+}
+function registerDependency(state, qualifier, path) {
+  const dependency = state.dependencyRegistry.registerDependency(qualifier);
+  const loc = getNearestLocFromPath(path);
+  if (loc != null) {
+    dependency.locs.push(loc);
+  }
+  return dependency;
+}
+function isOptionalDependency(name, path, state) {
+  const { allowOptionalDependencies } = state;
+  if (name === state.asyncRequireModulePathStringLiteral?.value) {
+    return false;
+  }
+  const isExcluded = () => Array.isArray(allowOptionalDependencies.exclude) && allowOptionalDependencies.exclude.includes(name);
+  if (!allowOptionalDependencies || isExcluded()) {
+    return false;
+  }
+  let sCount = 0;
+  let p = path;
+  while (p && sCount < 3) {
+    if (p.isStatement()) {
+      if (p.node.type === "BlockStatement") {
+        return p.parentPath != null && p.parentPath.node.type === "TryStatement" && p.key === "block";
+      }
+      sCount += 1;
+    }
+    p = p.parentPath;
+  }
+  return false;
+}
+function getModuleNameFromCallArgs(path) {
+  const expectedCount = path.node.callee.name === "__conditionallySplitJSResource" ? 2 : 1;
+  const args = path.get("arguments");
+  if (!Array.isArray(args) || args.length !== expectedCount) {
+    throw new InvalidRequireCallError(path);
+  }
+  const result = args[0].evaluate();
+  if (result.confident && typeof result.value === "string") {
+    return result.value;
+  }
+  return null;
+}
+collectDependencies.getModuleNameFromCallArgs = getModuleNameFromCallArgs;
+class InvalidRequireCallError extends Error {
+  constructor({ node }, message) {
+    const line = node.loc && node.loc.start && node.loc.start.line;
+    super([`Invalid call at line ${line || "<unknown>"}: ${generate(node).code}`, message].filter(Boolean).join("\n"));
+  }
+}
+collectDependencies.InvalidRequireCallError = InvalidRequireCallError;
+const dynamicRequireErrorTemplate = template.statement(`
+  (function(line) {
+    throw new Error(
+      'Dynamic require defined at line ' + line + '; not supported by Metro',
+    );
+  })(LINE)
+`);
+const makeAsyncRequireTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME)
+`);
+const makeAsyncPrefetchTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME)
+`);
+const makeJSResourceTemplate = template.statement(`
+  require(ASYNC_REQUIRE_MODULE_PATH).resource(MODULE_ID, MODULE_NAME)
+`);
+const DefaultDependencyTransformer = {
+  transformSyncRequire(path, dependency, state) {
+    const moduleIDExpression = createModuleIDExpression(dependency, state);
+    path.node.arguments = [moduleIDExpression];
+    if (state.keepRequireNames) {
+      path.node.arguments.push(types.stringLiteral(dependency.name));
+    }
+  },
+  transformImportCall(path, dependency, state) {
+    path.replaceWith(
+      makeAsyncRequireTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(state.asyncRequireModulePathStringLiteral),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+  transformJSResource(path, dependency, state) {
+    path.replaceWith(
+      makeJSResourceTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(state.asyncRequireModulePathStringLiteral),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+  transformPrefetch(path, dependency, state) {
+    path.replaceWith(
+      makeAsyncPrefetchTemplate({
+        ASYNC_REQUIRE_MODULE_PATH: nullthrows(state.asyncRequireModulePathStringLiteral),
+        MODULE_ID: createModuleIDExpression(dependency, state),
+        MODULE_NAME: createModuleNameLiteral(dependency)
+      })
+    );
+  },
+  transformIllegalDynamicRequire(path, state) {
+    path.replaceWith(
+      dynamicRequireErrorTemplate({
+        LINE: types.numericLiteral(path.node.loc?.start.line ?? 0)
+      })
+    );
+  }
+};
+function createModuleIDExpression(dependency, state) {
+  return types.memberExpression(
+    nullthrows(state.dependencyMapIdentifier),
+    types.numericLiteral(dependency.index),
+    true
+  );
+}
+function createModuleNameLiteral(dependency) {
+  return types.stringLiteral(dependency.name);
+}
+function getKeyForDependency(qualifier) {
+  let key = qualifier.name;
+  const { asyncType } = qualifier;
+  if (asyncType) {
+    key += ["", asyncType].join("\0");
+  }
+  const { contextParams } = qualifier;
+  if (contextParams) {
+    key += [
+      "",
+      "context",
+      String(contextParams.recursive),
+      String(contextParams.filter.pattern),
+      String(contextParams.filter.flags),
+      contextParams.mode
+      // Join together and append to the name:
+    ].join("\0");
+  }
+  return key;
+}
+class DefaultModuleDependencyRegistry {
+  _dependencies = /* @__PURE__ */ new Map();
+  registerDependency(qualifier) {
+    const key = getKeyForDependency(qualifier);
+    let dependency = this._dependencies.get(key);
+    if (dependency == null) {
+      const newDependency = {
+        name: qualifier.name,
+        asyncType: qualifier.asyncType,
+        locs: [],
+        index: this._dependencies.size,
+        key: crypto.createHash("sha1").update(key).digest("base64")
+      };
+      if (qualifier.optional) {
+        newDependency.isOptional = true;
+      }
+      if (qualifier.contextParams) {
+        newDependency.contextParams = qualifier.contextParams;
+      }
+      dependency = newDependency;
+    } else {
+      if (dependency.isOptional && !qualifier.optional) {
+        dependency = {
+          ...dependency,
+          isOptional: false
+        };
+      }
+    }
+    this._dependencies.set(key, dependency);
+    return dependency;
+  }
+  getDependencies() {
+    return Array.from(this._dependencies.values());
+  }
+}
+module.exports = collectDependencies;

package/dist/vendors/metro/src/ModuleGraph/worker/generate.js

@@ -0,0 +1,21 @@
+"use strict";
+const babelGenerate = require("@babel/generator").default;
+function generate(ast, filename, sourceCode) {
+  const generated = babelGenerate(
+    ast,
+    {
+      comments: false,
+      compact: true,
+      filename,
+      sourceFileName: filename,
+      sourceMaps: true,
+      sourceMapTarget: filename
+    },
+    sourceCode
+  );
+  if (generated.map) {
+    delete generated.map.sourcesContent;
+  }
+  return generated;
+}
+module.exports = generate;

package/dist/vendors/metro/src/ModuleGraph/worker/generateImportNames.js

@@ -0,0 +1,19 @@
+"use strict";
+const traverse = require("@babel/traverse").default;
+const nullthrows = require("nullthrows");
+function generateImportNames(ast) {
+  let importDefault;
+  let importAll;
+  traverse(ast, {
+    Program(path) {
+      importAll = path.scope.generateUid("$$_IMPORT_ALL");
+      importDefault = path.scope.generateUid("$$_IMPORT_DEFAULT");
+      path.stop();
+    }
+  });
+  return {
+    importAll: nullthrows(importAll),
+    importDefault: nullthrows(importDefault)
+  };
+}
+module.exports = generateImportNames;

package/dist/vendors/metro/src/ModuleGraph/worker/mergeSourceMaps.js

@@ -0,0 +1,29 @@
+"use strict";
+const sourceMap = require("source-map");
+function mergeSourceMaps(file, originalMap, secondMap) {
+  const merged = new sourceMap.SourceMapGenerator();
+  const inputMap = new sourceMap.SourceMapConsumer(originalMap);
+  new sourceMap.SourceMapConsumer(secondMap).eachMapping((mapping) => {
+    if (mapping.originalLine == null) {
+      return;
+    }
+    const original = inputMap.originalPositionFor({
+      line: mapping.originalLine,
+      column: mapping.originalColumn
+    });
+    if (original.line == null) {
+      return;
+    }
+    merged.addMapping({
+      generated: { line: mapping.generatedLine, column: mapping.generatedColumn },
+      original: { line: original.line, column: original.column || 0 },
+      source: file,
+      name: original.name || mapping.name
+    });
+  });
+  return {
+    ...merged.toJSON(),
+    sources: inputMap.sources
+  };
+}
+module.exports = mergeSourceMaps;

package/dist/vendors/metro/src/Server/MultipartResponse.js

@@ -0,0 +1,57 @@
+"use strict";
+const accepts = require("accepts");
+const CRLF = "\r\n";
+const BOUNDARY = "3beqjf3apnqeu3h5jqorms4i";
+class MultipartResponse {
+  static wrapIfSupported(req, res) {
+    if (accepts(req).types().includes("multipart/mixed")) {
+      return new MultipartResponse(res);
+    }
+    return res;
+  }
+  static serializeHeaders(headers) {
+    return Object.keys(headers).map((key) => `${key}: ${headers[key]}`).join(CRLF);
+  }
+  res;
+  headers;
+  constructor(res) {
+    this.res = res;
+    this.headers = {};
+    res.writeHead(200, {
+      "Content-Type": `multipart/mixed; boundary="${BOUNDARY}"`
+    });
+    res.write("If you are seeing this, your client does not support multipart response");
+  }
+  writeChunk(headers, data, isLast = false) {
+    if (this.res.finished) {
+      return;
+    }
+    this.res.write(`${CRLF}--${BOUNDARY}${CRLF}`);
+    if (headers) {
+      this.res.write(MultipartResponse.serializeHeaders(headers) + CRLF + CRLF);
+    }
+    if (data != null) {
+      this.res.write(data);
+    }
+    if (isLast) {
+      this.res.write(`${CRLF}--${BOUNDARY}--${CRLF}`);
+    }
+  }
+  writeHead(status, headers) {
+    this.setHeader("X-Http-Status", status);
+    if (!headers) {
+      return;
+    }
+    for (const key in headers) {
+      this.setHeader(key, headers[key]);
+    }
+  }
+  setHeader(name, value) {
+    this.headers[name] = value;
+  }
+  end(data) {
+    this.writeChunk(this.headers, data, true);
+    this.res.end();
+  }
+}
+module.exports = MultipartResponse;

package/dist/vendors/metro/src/Server/symbolicate.js

@@ -0,0 +1,109 @@
+"use strict";
+const { greatestLowerBound } = require("metro-source-map/src/Consumer/search");
+const { SourceMetadataMapConsumer } = require("metro-symbolicate/src/Symbolication");
+function createFunctionNameGetter(module2) {
+  const consumer = new SourceMetadataMapConsumer(
+    {
+      version: 3,
+      mappings: "",
+      sources: ["dummy"],
+      names: [],
+      x_facebook_sources: [[module2.functionMap]]
+    },
+    (name) => name
+    /* no normalization needed */
+  );
+  return ({ line1Based, column0Based }) => consumer.functionNameFor({
+    line: line1Based,
+    column: column0Based,
+    source: "dummy"
+  });
+}
+async function symbolicate(stack, maps, config) {
+  const mapsByUrl = /* @__PURE__ */ new Map();
+  for (const [url, map] of maps) {
+    mapsByUrl.set(url, map);
+  }
+  const functionNameGetters = /* @__PURE__ */ new Map();
+  function findModule(frame) {
+    const map = mapsByUrl.get(frame.file);
+    if (!map || frame.lineNumber == null) {
+      return null;
+    }
+    const moduleIndex = greatestLowerBound(
+      map,
+      frame.lineNumber,
+      (target, candidate) => target - candidate.firstLine1Based
+    );
+    if (moduleIndex == null) {
+      return null;
+    }
+    return map[moduleIndex];
+  }
+  function findOriginalPos(frame, module2) {
+    if (module2.map == null || frame.lineNumber == null || frame.column == null) {
+      return null;
+    }
+    const generatedPosInModule = {
+      line1Based: frame.lineNumber - module2.firstLine1Based + 1,
+      column0Based: frame.column
+    };
+    const mappingIndex = greatestLowerBound(module2.map, generatedPosInModule, (target, candidate) => {
+      if (target.line1Based === candidate[0]) {
+        return target.column0Based - candidate[1];
+      }
+      return target.line1Based - candidate[0];
+    });
+    if (mappingIndex == null) {
+      return null;
+    }
+    const mapping = module2.map[mappingIndex];
+    if (mapping[0] !== generatedPosInModule.line1Based || mapping.length < 4) {
+      return null;
+    }
+    return {
+      // $FlowFixMe: Length checks do not refine tuple unions.
+      line1Based: mapping[2],
+      // $FlowFixMe: Length checks do not refine tuple unions.
+      column0Based: mapping[3]
+    };
+  }
+  function findFunctionName(originalPos, module2) {
+    if (module2.functionMap) {
+      let getFunctionName = functionNameGetters.get(module2);
+      if (!getFunctionName) {
+        getFunctionName = createFunctionNameGetter(module2);
+        functionNameGetters.set(module2, getFunctionName);
+      }
+      return getFunctionName(originalPos);
+    }
+    return null;
+  }
+  function symbolicateFrame(frame) {
+    const module2 = findModule(frame);
+    if (!module2) {
+      return frame;
+    }
+    if (!Array.isArray(module2.map)) {
+      throw new Error(`Unexpected module with serialized source map found: ${module2.path}`);
+    }
+    const originalPos = findOriginalPos(frame, module2);
+    if (!originalPos) {
+      return frame;
+    }
+    const methodName = findFunctionName(originalPos, module2) ?? frame.methodName;
+    return {
+      ...frame,
+      methodName,
+      file: module2.path,
+      lineNumber: originalPos.line1Based,
+      column: originalPos.column0Based
+    };
+  }
+  async function customizeFrame(frame) {
+    const customizations = await config.symbolicator.customizeFrame(frame) || {};
+    return { ...frame, collapse: false, ...customizations };
+  }
+  return Promise.all(stack.map(symbolicateFrame).map(customizeFrame));
+}
+module.exports = symbolicate;