@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro/src/shared/output/RamBundle/util.js

@@ -0,0 +1,94 @@
+"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_countLines = __toESM(require("../../../lib/countLines"));
+const invariant = require("invariant");
+function lineToLineSourceMap(source, filename = "") {
+  const firstLine = "AAAA;";
+  const line = "AACA;";
+  return {
+    file: filename,
+    mappings: firstLine + Array((0, import_countLines.default)(source)).join(line),
+    sources: [filename],
+    names: [],
+    version: 3
+  };
+}
+const wrapperEnd = (wrappedCode) => wrappedCode.indexOf("{") + 1;
+const Section = (line, column, map) => ({
+  map,
+  offset: { line, column }
+});
+function combineSourceMaps(modules, moduleGroups, options) {
+  const sections = combineMaps(modules, null, moduleGroups, options);
+  return { sections, version: 3 };
+}
+function combineSourceMapsAddingOffsets(modules, x_metro_module_paths, moduleGroups, options) {
+  const x_facebook_offsets = [];
+  const sections = combineMaps(modules, x_facebook_offsets, moduleGroups, options);
+  return { sections, version: 3, x_facebook_offsets, x_metro_module_paths };
+}
+function combineMaps(modules, offsets, moduleGroups, options) {
+  const sections = [];
+  let line = 0;
+  modules.forEach((moduleTransport) => {
+    const { code, id, name } = moduleTransport;
+    let column = 0;
+    let group;
+    let groupLines = 0;
+    let { map } = moduleTransport;
+    if (moduleGroups && moduleGroups.modulesInGroups.has(id)) {
+      return;
+    }
+    if (offsets != null) {
+      group = moduleGroups && moduleGroups.groups.get(id);
+      if (group && moduleGroups) {
+        const { modulesById } = moduleGroups;
+        const otherModules = Array.from(group || []).map((moduleId) => modulesById.get(moduleId)).filter(Boolean);
+        otherModules.forEach((m) => {
+          groupLines += (0, import_countLines.default)(m.code);
+        });
+        map = combineSourceMaps([moduleTransport].concat(otherModules));
+      }
+      column = options && options.fixWrapperOffset ? wrapperEnd(code) : 0;
+    }
+    invariant(!Array.isArray(map), "Random Access Bundle source maps cannot be built from raw mappings");
+    sections.push(Section(line, column, map || lineToLineSourceMap(code, name)));
+    if (offsets != null && id != null) {
+      offsets[id] = line;
+      for (const moduleId of group || []) {
+        offsets[moduleId] = line;
+      }
+    }
+    line += (0, import_countLines.default)(code) + groupLines;
+  });
+  return sections;
+}
+const joinModules = (modules) => modules.map((m) => m.code).join("\n");
+module.exports = {
+  combineSourceMaps,
+  combineSourceMapsAddingOffsets,
+  countLines: import_countLines.default,
+  joinModules,
+  lineToLineSourceMap
+};

package/dist/vendors/metro/src/shared/output/RamBundle/write-sourcemap.js

@@ -0,0 +1,12 @@
+"use strict";
+const writeFile = require("../writeFile");
+function writeSourcemap(fileName, contents, log) {
+  if (!fileName) {
+    return Promise.resolve();
+  }
+  log("Writing sourcemap output to:", fileName);
+  const writeMap = writeFile(fileName, contents, null);
+  writeMap.then(() => log("Done writing sourcemap output"));
+  return writeMap;
+}
+module.exports = writeSourcemap;

package/dist/vendors/metro/src/shared/output/RamBundle.js

@@ -0,0 +1,18 @@
+"use strict";
+const Server = require("../../Server");
+const asAssets = require("./RamBundle/as-assets");
+const asIndexedFile = require("./RamBundle/as-indexed-file").save;
+async function build(packagerClient, requestOptions) {
+  const options = {
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "ram"
+  };
+  return await packagerClient.getRamBundleInfo(options);
+}
+function save(bundle, options, log) {
+  return options.platform === "android" && !(options.indexedRamBundle === true) ? asAssets(bundle, options, log) : asIndexedFile(bundle, options, log);
+}
+exports.build = build;
+exports.save = save;
+exports.formatName = "bundle";

package/dist/vendors/metro/src/shared/output/bundle.flow.js

@@ -0,0 +1,42 @@
+"use strict";
+const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+const Server = require("../../Server");
+const writeFile = require("./writeFile");
+function buildBundle(packagerClient, requestOptions) {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "bundle"
+  });
+}
+function relativateSerializedMap(map, sourceMapSourcesRoot) {
+  const sourceMap = JSON.parse(map);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+  const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+  const writeFns = [];
+  writeFns.push(async () => {
+    log("Writing bundle output to:", bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log("Done writing bundle output");
+  });
+  if (sourcemapOutput) {
+    let { map } = bundle;
+    if (sourcemapSourcesRoot !== void 0) {
+      log("start relativating source map");
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log("finished relativating");
+    }
+    writeFns.push(async () => {
+      log("Writing sourcemap output to:", sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log("Done writing sourcemap output");
+    });
+  }
+  await Promise.all(writeFns.map((cb) => cb()));
+}
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = "bundle";

package/dist/vendors/metro/src/shared/output/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+try {
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {
+}
+module.exports = require("./bundle.flow");

package/dist/vendors/metro/src/shared/output/meta.js

@@ -0,0 +1,31 @@
+"use strict";
+const crypto = require("crypto");
+const isUTF8 = (encoding) => /^utf-?8$/i.test(encoding);
+const constantFor = (encoding) => /^ascii$/i.test(encoding) ? 1 : isUTF8(encoding) ? 2 : /^(?:utf-?16(?:le)?|ucs-?2)$/.test(encoding) ? 3 : 0;
+module.exports = function(code, encoding = "utf8") {
+  const buffer = asBuffer(code, encoding);
+  const hash = crypto.createHash("sha1");
+  hash.update(buffer);
+  const digest = hash.digest("buffer");
+  const signature = Buffer.alloc(digest.length + 1);
+  digest.copy(signature);
+  signature.writeUInt8(constantFor(tryAsciiPromotion(buffer, encoding)), signature.length - 1);
+  return signature;
+};
+function tryAsciiPromotion(buffer, encoding) {
+  if (!isUTF8(encoding)) {
+    return encoding;
+  }
+  for (let i = 0, n = buffer.length; i < n; i++) {
+    if (buffer[i] > 127) {
+      return encoding;
+    }
+  }
+  return "ascii";
+}
+function asBuffer(x, encoding) {
+  if (typeof x !== "string") {
+    return x;
+  }
+  return Buffer.from(x, encoding);
+}

package/dist/vendors/metro/src/shared/output/unbundle.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./RamBundle");

package/dist/vendors/metro/src/shared/output/writeFile.js

@@ -0,0 +1,6 @@
+"use strict";
+const denodeify = require("denodeify");
+const fs = require("fs");
+const throat = require("throat");
+const writeFile = throat(128, denodeify(fs.writeFile));
+module.exports = writeFile;

package/dist/vendors/metro/src/shared/types.flow.js

@@ -0,0 +1 @@
+"use strict";

package/dist/vendors/metro-config/src/configTypes.flow.js

@@ -0,0 +1 @@
+"use strict";

package/dist/vendors/metro-config/src/defaults/defaults.js

@@ -0,0 +1,66 @@
+"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
+));
+const defaultCreateModuleIdFactory = require("../../../metro/src/lib/createModuleIdFactory");
+exports.assetExts = [
+  // Image formats
+  "bmp",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "psd",
+  "svg",
+  "webp",
+  // Video formats
+  "m4v",
+  "mov",
+  "mp4",
+  "mpeg",
+  "mpg",
+  "webm",
+  // Audio formats
+  "aac",
+  "aiff",
+  "caf",
+  "m4a",
+  "mp3",
+  "wav",
+  // Document formats
+  "html",
+  "pdf",
+  "yaml",
+  "yml",
+  // Font formats
+  "otf",
+  "ttf",
+  // Archives (virtual files)
+  "zip"
+];
+exports.assetResolutions = ["1", "1.5", "2", "3", "4"];
+exports.sourceExts = ["js", "jsx", "json", "ts", "tsx"];
+exports.additionalExts = ["cjs", "mjs"];
+exports.moduleSystem = require.resolve("metro-runtime/src/polyfills/require.js");
+exports.platforms = ["ios", "android", "windows", "web"];
+exports.DEFAULT_METRO_MINIFIER_PATH = "metro-minify-uglify";
+exports.defaultCreateModuleIdFactory = defaultCreateModuleIdFactory;

package/dist/vendors/metro-config/src/defaults/exclusionList.d.ts

@@ -0,0 +1,3 @@
+declare function exclusionList(additionalExclusions?: (RegExp | string)[]): RegExp;
+
+export default exclusionList;

package/dist/vendors/metro-config/src/defaults/exclusionList.js

@@ -0,0 +1,17 @@
+"use strict";
+var path = require("path");
+var list = [/\/__tests__\/.*/];
+function escapeRegExp(pattern) {
+  if (Object.prototype.toString.call(pattern) === "[object RegExp]") {
+    return pattern.source.replace(/\/|\\\//g, "\\" + path.sep);
+  } else if (typeof pattern === "string") {
+    var escaped = pattern.replace(/[\-\[\]\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+    return escaped.replace(/\//g, "\\" + path.sep);
+  } else {
+    throw new Error("Unexpected exclusion pattern: " + pattern);
+  }
+}
+function exclusionList(additionalExclusions) {
+  return new RegExp("(" + (additionalExclusions || []).concat(list).map(escapeRegExp).join("|") + ")$");
+}
+module.exports = exclusionList;

package/dist/vendors/metro-config/src/defaults/index.d.ts

@@ -0,0 +1,5 @@
+declare function getDefaultConfig(rootPath: string): any;
+declare function getDefaultValues(rootPath: string): any;
+
+export default getDefaultConfig;
+export { getDefaultValues };

package/dist/vendors/metro-config/src/defaults/index.js

@@ -0,0 +1,161 @@
+"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
+));
+const {
+  DEFAULT_METRO_MINIFIER_PATH,
+  assetExts,
+  assetResolutions,
+  additionalExts,
+  defaultCreateModuleIdFactory,
+  platforms,
+  sourceExts
+} = require("./defaults");
+const exclusionList = require("./exclusionList");
+const { FileStore } = require("metro-cache");
+const { Terminal } = require("../../../metro-core/src");
+const getMaxWorkers = require("../../../metro/src/lib/getMaxWorkers");
+const TerminalReporter = require("../../../metro/src/lib/TerminalReporter");
+const os = require("os");
+const path = require("path");
+const getDefaultValues = (projectRoot) => ({
+  resolver: {
+    assetExts,
+    assetResolutions,
+    platforms,
+    sourceExts,
+    blockList: exclusionList(),
+    dependencyExtractor: void 0,
+    disableHierarchicalLookup: false,
+    emptyModulePath: require.resolve("metro-runtime/src/modules/empty-module.js"),
+    extraNodeModules: {},
+    hasteImplModulePath: void 0,
+    nodeModulesPaths: [],
+    resolveRequest: null,
+    resolverMainFields: ["browser", "main"],
+    useWatchman: true,
+    requireCycleIgnorePatterns: [/(^|\/|\\)node_modules($|\/|\\)/]
+  },
+  serializer: {
+    polyfillModuleNames: [],
+    getRunModuleStatement: (moduleId) => `__r(${JSON.stringify(moduleId)});`,
+    getPolyfills: () => [],
+    postProcessBundleSourcemap: ({ code, map, outFileName }) => ({ code, map }),
+    getModulesRunBeforeMainModule: () => [],
+    processModuleFilter: (module2) => true,
+    createModuleIdFactory: defaultCreateModuleIdFactory,
+    experimentalSerializerHook: () => {
+    },
+    customSerializer: null
+  },
+  server: {
+    useGlobalHotkey: true,
+    port: 8080,
+    enhanceMiddleware: (middleware) => middleware,
+    rewriteRequestUrl: (url) => url,
+    runInspectorProxy: true,
+    verifyConnections: false,
+    unstable_serverRoot: null
+  },
+  symbolicator: {
+    customizeFrame: () => {
+    }
+  },
+  transformer: {
+    assetPlugins: [],
+    asyncRequireModulePath: "metro-runtime/src/modules/asyncRequire",
+    assetRegistryPath: "missing-asset-registry-path",
+    babelTransformerPath: "metro-babel-transformer",
+    dynamicDepsInPackages: "throwAtRuntime",
+    enableBabelRCLookup: true,
+    enableBabelRuntime: true,
+    experimentalImportBundleSupport: false,
+    getTransformOptions: async () => ({
+      transform: {
+        experimentalImportSupport: false,
+        inlineRequires: false,
+        unstable_disableES6Transforms: false
+      },
+      preloadedModules: false,
+      ramGroups: []
+    }),
+    globalPrefix: "",
+    hermesParser: false,
+    minifierConfig: {
+      mangle: {
+        toplevel: false
+      },
+      output: {
+        ascii_only: true,
+        quote_style: 3,
+        wrap_iife: true
+      },
+      sourceMap: {
+        includeSources: false
+      },
+      toplevel: false,
+      compress: {
+        // reduce_funcs inlines single-use functions, which cause perf regressions.
+        reduce_funcs: false
+      }
+    },
+    minifierPath: DEFAULT_METRO_MINIFIER_PATH,
+    optimizationSizeLimit: 150 * 1024,
+    // 150 KiB.
+    transformVariants: { default: {} },
+    workerPath: "metro/src/DeltaBundler/Worker",
+    publicPath: "/assets",
+    allowOptionalDependencies: false,
+    unstable_allowRequireContext: false,
+    unstable_collectDependenciesPath: "metro/src/ModuleGraph/worker/collectDependencies.js",
+    unstable_dependencyMapReservedName: null,
+    unstable_disableModuleWrapping: false,
+    unstable_disableNormalizePseudoGlobals: false,
+    unstable_compactOutput: false
+  },
+  watcher: {
+    additionalExts,
+    watchman: {
+      deferStates: ["hg.update"]
+    }
+  },
+  cacheStores: [
+    new FileStore({
+      root: path.join(os.tmpdir(), "metro-cache")
+    })
+  ],
+  cacheVersion: "1.0",
+  // We assume the default project path is two levels up from
+  // node_modules/metro/
+  projectRoot: projectRoot || path.resolve(__dirname, "../../.."),
+  stickyWorkers: true,
+  watchFolders: [],
+  transformerPath: "metro-transform-worker",
+  maxWorkers: getMaxWorkers(),
+  resetCache: false,
+  reporter: new TerminalReporter(new Terminal(process.stdout))
+});
+async function getDefaultConfig(rootPath) {
+  return getDefaultValues(rootPath);
+}
+module.exports = getDefaultConfig;
+module.exports.getDefaultValues = getDefaultValues;

package/dist/vendors/metro-config/src/defaults/validConfig.js

@@ -0,0 +1,28 @@
+"use strict";
+module.exports = async () => {
+  const defaultConfig = await require("./index")("/path/to/project");
+  const validConfig = {
+    ...defaultConfig,
+    resolver: {
+      ...defaultConfig.resolver,
+      resolveRequest: function CustomResolver() {
+      },
+      hasteImplModulePath: "./path"
+    },
+    server: {
+      ...defaultConfig.server,
+      unstable_serverRoot: ""
+    },
+    transformer: {
+      ...defaultConfig.transformer,
+      getTransformOptions: function getTransformOptions() {
+      }
+    },
+    serializer: {
+      ...defaultConfig.serializer,
+      customSerializer: function customSerializer() {
+      }
+    }
+  };
+  return validConfig;
+};

package/dist/vendors/metro-config/src/index.js

@@ -0,0 +1,9 @@
+"use strict";
+const getDefaultConfig = require("./defaults");
+const { loadConfig, mergeConfig, resolveConfig } = require("./loadConfig");
+module.exports = {
+  loadConfig,
+  resolveConfig,
+  mergeConfig,
+  getDefaultConfig
+};

package/dist/vendors/metro-config/src/loadConfig.d.ts

@@ -0,0 +1,4 @@
+declare function loadConfig(argv: any, defaultConfigOverrides: any): Promise<any>;
+declare function mergeConfig(defaultConfig: any, ...configs: any[]): any;
+
+export { loadConfig, mergeConfig };