@granite-js/mpack 0.0.1

package/dist/vendors/@react-native/dev-middleware/InspectorProxy.js

@@ -0,0 +1,169 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InspectorProxy_exports = {};
+__export(InspectorProxy_exports, {
+  InspectorProxy: () => InspectorProxy
+});
+module.exports = __toCommonJS(InspectorProxy_exports);
+var import_url = __toESM(require("url"));
+var import_dev_middleware = require("@react-native/dev-middleware");
+var ws = __toESM(require("ws"));
+var import_Device = require("./Device");
+var import_logger = require("../../../logger");
+const experiments = {
+  enableNewDebugger: false,
+  enableNetworkInspector: false,
+  enableOpenDebuggerRedirect: false
+};
+const PAGES_LIST_JSON_URL = "/json";
+const PAGES_LIST_JSON_URL_2 = "/json/list";
+const PAGES_LIST_JSON_VERSION_URL = "/json/version";
+const INTERNAL_ERROR_CODE = 1011;
+class InspectorProxy extends import_dev_middleware.unstable_InspectorProxy {
+  constructor({ root, serverBaseUrl }) {
+    super(root, serverBaseUrl, null, experiments);
+  }
+  /**
+   * 커스텀 Device 를 사용하기 위해 `InspectorProxy.createWebSocketListeners` 를 재구성한 메소드
+   */
+  createWebSocketServers({
+    onDeviceWebSocketConnected,
+    onDebuggerWebSocketConnected
+  }) {
+    return {
+      deviceSocketServer: this.createDeviceWebSocketServer(onDeviceWebSocketConnected),
+      debuggerSocketServer: this.createDebuggerWebSocketServer(onDebuggerWebSocketConnected)
+    };
+  }
+  /**
+   * Fastify 에서 사용할 수 있도록 `InspectorProxy.processRequest` 의 인터페이스를 재구성한 메소드
+   */
+  handleRequest(request, reply, done) {
+    const { pathname } = import_url.default.parse(request.url);
+    switch (pathname) {
+      case PAGES_LIST_JSON_URL:
+      case PAGES_LIST_JSON_URL_2:
+        this.sendJsonResponse(reply, this.getPageDescriptions());
+        break;
+      case PAGES_LIST_JSON_VERSION_URL:
+        this.sendJsonResponse(reply, { Browser: "Mobile JavaScript", "Protocol-Version": "1.1" });
+        break;
+    }
+    done();
+  }
+  /**
+   * 토스 커스텀 디버거를 띄우기 위해 내부 devices 를 노출시켜야 함
+   */
+  getDevices() {
+    return this._devices;
+  }
+  sendJsonResponse(reply, object) {
+    const data = JSON.stringify(object, null, 2);
+    reply.status(200).headers({
+      "Content-Type": "application/json; charset=UTF-8",
+      "Cache-Control": "no-cache",
+      "Content-Length": data.length.toString(),
+      Connection: "close"
+    }).send(data);
+  }
+  createDeviceWebSocketServer(onConnected) {
+    const wss = new ws.WebSocketServer({
+      noServer: true,
+      perMessageDeflate: true
+    });
+    wss.on("connection", async (socket, request) => {
+      try {
+        const fallbackDeviceId = String(this._deviceCounter++);
+        const query = import_url.default.parse(request.url || "", true).query || {};
+        const deviceId = query.device || fallbackDeviceId;
+        const deviceName = query.name || "Unknown";
+        const appName = query.app || "Unknown";
+        import_logger.logger.trace("Device \uC18C\uCF13 \uC5F0\uACB0\uB428", { deviceId, deviceName, appName });
+        if (Array.isArray(deviceId) || Array.isArray(deviceName) || Array.isArray(appName)) {
+          return;
+        }
+        const oldDevice = this._devices.get(deviceId);
+        const newDevice = new import_Device.Device(deviceId, deviceName, appName, socket, this._projectRoot);
+        if (oldDevice) {
+          oldDevice.handleDuplicateDeviceConnection(newDevice);
+        }
+        this._devices.set(deviceId, newDevice);
+        socket.on("close", () => {
+          import_logger.logger.trace("Device \uC18C\uCF13 \uC5F0\uACB0 \uB04A\uAE40", { deviceId });
+          this._devices.delete(deviceId);
+        });
+        onConnected(socket);
+      } catch (error) {
+        const errorMessage = error?.toString() ?? "Unknown error";
+        import_logger.logger.error("Device \uC18C\uCF13 \uC5D0\uB7EC", errorMessage);
+        socket.close(INTERNAL_ERROR_CODE, errorMessage);
+      }
+    });
+    return wss;
+  }
+  createDebuggerWebSocketServer(onConnected) {
+    const wss = new ws.WebSocketServer({
+      noServer: true,
+      perMessageDeflate: false,
+      maxPayload: 0
+    });
+    wss.on("connection", async (socket, request) => {
+      try {
+        const query = import_url.default.parse(request.url || "", true).query || {};
+        const deviceId = query.device;
+        const pageId = query.page;
+        const userAgent = query.userAgent;
+        import_logger.logger.trace("Debugger \uC18C\uCF13 \uC5F0\uACB0\uB428", { deviceId, pageId, userAgent });
+        if (deviceId == null || pageId == null) {
+          throw new Error("\uCEE4\uB125\uC158 \uC694\uCCAD\uC5D0 device, page \uB9E4\uAC1C\uBCC0\uC218\uAC00 \uC874\uC7AC\uD574\uC57C \uD569\uB2C8\uB2E4");
+        }
+        if (Array.isArray(deviceId) || Array.isArray(pageId) || Array.isArray(userAgent)) {
+          return;
+        }
+        const device = this._devices.get(deviceId);
+        if (device == null) {
+          throw new Error(`${deviceId} \uC5D0 \uD574\uB2F9\uD558\uB294 \uAE30\uAE30\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
+        }
+        device.handleDebuggerConnection(socket, pageId, {
+          userAgent: request.headers["user-agent"] ?? userAgent ?? null
+        });
+        onConnected(socket);
+      } catch (error) {
+        const errorMessage = error?.toString() ?? "Unknown error";
+        import_logger.logger.error("Debugger \uC18C\uCF13 \uC5D0\uB7EC", errorMessage);
+        socket.close(INTERNAL_ERROR_CODE, errorMessage);
+      }
+    });
+    return wss;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InspectorProxy
+});

package/dist/vendors/@react-native/dev-middleware/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Device';
+export * from './InspectorProxy';
+export * from './types';

package/dist/vendors/@react-native/dev-middleware/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_middleware_exports = {};
+module.exports = __toCommonJS(dev_middleware_exports);
+__reExport(dev_middleware_exports, require("./Device"), module.exports);
+__reExport(dev_middleware_exports, require("./InspectorProxy"), module.exports);
+__reExport(dev_middleware_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Device"),
+  ...require("./InspectorProxy"),
+  ...require("./types")
+});

package/dist/vendors/@react-native/dev-middleware/types.d.ts

@@ -0,0 +1,54 @@
+export type CdpRequestId = number;
+/**
+ * https://github.com/ChromeDevTools/devtools-protocol/blob/master/types/protocol.d.ts
+ */
+export type SetBreakpointByUrlRequest = {
+    id: CdpRequestId;
+    method: 'Debugger.setBreakpointByUrl';
+    params: {
+        lineNumber: number;
+        url?: string;
+        urlRegex?: string;
+        scriptHash?: string;
+        columnNumber?: number;
+        condition?: string;
+    };
+};
+export type GetScriptSourceRequest = {
+    id: CdpRequestId;
+    method: 'Debugger.getScriptSource';
+    params: {
+        scriptId: string;
+    };
+};
+export type GetResponseBodyRequest = {
+    id: CdpRequestId;
+    method: 'Network.getResponseBody';
+    params: {
+        requestId: CdpRequestId;
+    };
+};
+/**
+ * @deprecated
+ */
+export interface LegacyNetworkResponseData {
+    method: 'Bedrock.networkResponseData';
+    params: {
+        requestId: string;
+        data: string;
+        base64Encoded: boolean;
+    };
+}
+/**
+ * Granite 커스텀 이벤트
+ */
+export interface NetworkResponseData {
+    method: 'Granite.networkResponseData';
+    params: {
+        requestId: string;
+        data: string;
+        base64Encoded: boolean;
+    };
+}
+export type DebuggerRequest = SetBreakpointByUrlRequest | GetScriptSourceRequest | GetResponseBodyRequest;
+export type CustomEvent = LegacyNetworkResponseData | NetworkResponseData;

package/dist/vendors/@react-native/dev-middleware/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/vendors/@react-native-community/cli-server-api/createWebSocketEndpoints.d.ts

@@ -0,0 +1,23 @@
+import { MessageBroadcaster } from '../../../server/types';
+interface WebSocketEndpointOptions {
+    broadcast: MessageBroadcaster;
+}
+/**
+ * import('@react-native-community/cli-server-api').createDevServerMiddleware 의 경우
+ * 불필요한 미들웨어 구성까지 포함시키고 있기 때문에 필요한 대상만 가져와서 사용
+ */
+export declare function createWebSocketEndpoints(options: WebSocketEndpointOptions): {
+    debuggerProxySocket: {
+        server: ws.Server;
+        isDebuggerConnected: () => boolean;
+    };
+    eventsSocket: {
+        server: WebSocketServer;
+        reportEvent: (event: any) => void;
+    };
+    messageSocket: {
+        server: WebSocketServer;
+        broadcast: (method: string, params?: Record<string, any>) => void;
+    };
+};
+export {};

package/dist/vendors/@react-native-community/cli-server-api/createWebSocketEndpoints.js

@@ -0,0 +1,47 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createWebSocketEndpoints_exports = {};
+__export(createWebSocketEndpoints_exports, {
+  createWebSocketEndpoints: () => createWebSocketEndpoints
+});
+module.exports = __toCommonJS(createWebSocketEndpoints_exports);
+var import_createDebuggerProxyEndpoint = __toESM(require("@react-native-community/cli-server-api/build/websocket/createDebuggerProxyEndpoint"));
+var import_createEventsSocketEndpoint = __toESM(require("@react-native-community/cli-server-api/build/websocket/createEventsSocketEndpoint"));
+var import_createMessageSocketEndpoint = __toESM(require("@react-native-community/cli-server-api/build/websocket/createMessageSocketEndpoint"));
+function createWebSocketEndpoints(options) {
+  return {
+    debuggerProxySocket: (0, import_createDebuggerProxyEndpoint.default)(),
+    eventsSocket: (0, import_createEventsSocketEndpoint.default)((method, params) => options.broadcast(method, params)),
+    messageSocket: (0, import_createMessageSocketEndpoint.default)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebSocketEndpoints
+});

package/dist/vendors/@react-native-community/cli-server-api/index.d.ts

@@ -0,0 +1 @@
+export * from './createWebSocketEndpoints';

package/dist/vendors/@react-native-community/cli-server-api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_server_api_exports = {};
+module.exports = __toCommonJS(cli_server_api_exports);
+__reExport(cli_server_api_exports, require("./createWebSocketEndpoints"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./createWebSocketEndpoints")
+});

package/dist/vendors/index.d.ts

@@ -0,0 +1,27 @@
+import TerminalReporter from './metro/src/lib/TerminalReporter';
+import { getDefaultValues } from './metro-config/src/defaults';
+import { loadConfig, mergeConfig } from './metro-config/src/loadConfig';
+import Terminal from './metro-core/src/Terminal';
+import InspectorProxy from './metro-inspector-proxy/src/InspectorProxy';
+declare const vendorModules: {
+    readonly metro: {
+        readonly Metro: {
+            runServer(config: any, options: any): Promise<any>;
+            runBuild(config: any, options: any): Promise<any>;
+        };
+        readonly TerminalReporter: typeof TerminalReporter;
+    };
+    readonly 'metro-config': {
+        readonly getDefaultValues: typeof getDefaultValues;
+        readonly loadConfig: typeof loadConfig;
+        readonly mergeConfig: typeof mergeConfig;
+    };
+    readonly 'metro-core': {
+        readonly Terminal: typeof Terminal;
+    };
+    readonly 'metro-inspector-proxy': {
+        readonly InspectorProxy: typeof InspectorProxy;
+    };
+};
+export declare function getModule<Source extends keyof typeof vendorModules>(source: Source): (typeof vendorModules)[Source];
+export {};

package/dist/vendors/index.js

@@ -0,0 +1,63 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vendors_exports = {};
+__export(vendors_exports, {
+  getModule: () => getModule
+});
+module.exports = __toCommonJS(vendors_exports);
+var import_src = __toESM(require("./metro/src"));
+var import_TerminalReporter = __toESM(require("./metro/src/lib/TerminalReporter"));
+var import_defaults = require("./metro-config/src/defaults");
+var import_loadConfig = require("./metro-config/src/loadConfig");
+var import_Terminal = __toESM(require("./metro-core/src/Terminal"));
+var import_InspectorProxy = __toESM(require("./metro-inspector-proxy/src/InspectorProxy"));
+const vendorModules = {
+  metro: {
+    Metro: import_src.default,
+    TerminalReporter: import_TerminalReporter.default
+  },
+  "metro-config": {
+    getDefaultValues: import_defaults.getDefaultValues,
+    loadConfig: import_loadConfig.loadConfig,
+    mergeConfig: import_loadConfig.mergeConfig
+  },
+  "metro-core": {
+    Terminal: import_Terminal.default
+  },
+  "metro-inspector-proxy": {
+    InspectorProxy: import_InspectorProxy.default
+  }
+};
+function getModule(source) {
+  return vendorModules[source];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModule
+});

package/dist/vendors/metro/src/Assets.js

@@ -0,0 +1,159 @@
+"use strict";
+const { isAssetTypeAnImage } = require("./Bundler/util");
+const AssetPaths = require("./node-haste/lib/AssetPaths");
+const crypto = require("crypto");
+const denodeify = require("denodeify");
+const fs = require("fs");
+const imageSize = require("image-size");
+const path = require("path");
+const readDir = denodeify(fs.readdir);
+const readFile = denodeify(fs.readFile);
+const hashFiles = denodeify(function hashFilesCb(files, hash, callback) {
+  if (!files.length) {
+    callback(null);
+    return;
+  }
+  const file = files.shift();
+  fs.readFile(file, (err, data) => {
+    if (err) {
+      callback(err);
+      return;
+    } else {
+      hash.update(data);
+      hashFilesCb(files, hash, callback);
+    }
+  });
+});
+function buildAssetMap(dir, files, platform) {
+  const platforms = new Set(platform != null ? [platform] : []);
+  const assets = files.map((file) => AssetPaths.tryParse(file, platforms));
+  const map = /* @__PURE__ */ new Map();
+  assets.forEach(function(asset, i) {
+    if (asset == null) {
+      return;
+    }
+    const file = files[i];
+    const assetKey = getAssetKey(asset.assetName, asset.platform);
+    let record = map.get(assetKey);
+    if (!record) {
+      record = {
+        scales: [],
+        files: []
+      };
+      map.set(assetKey, record);
+    }
+    let insertIndex;
+    const length = record.scales.length;
+    for (insertIndex = 0; insertIndex < length; insertIndex++) {
+      if (asset.resolution < record.scales[insertIndex]) {
+        break;
+      }
+    }
+    record.scales.splice(insertIndex, 0, asset.resolution);
+    record.files.splice(insertIndex, 0, path.join(dir, file));
+  });
+  return map;
+}
+function getAssetKey(assetName, platform) {
+  if (platform != null) {
+    return `${assetName} : ${platform}`;
+  } else {
+    return assetName;
+  }
+}
+async function getAbsoluteAssetRecord(assetPath, platform = null) {
+  const filename = path.basename(assetPath);
+  const dir = path.dirname(assetPath);
+  const files = await readDir(dir);
+  const assetData = AssetPaths.parse(filename, new Set(platform != null ? [platform] : []));
+  const map = buildAssetMap(dir, files, platform);
+  let record;
+  if (platform != null) {
+    record = map.get(getAssetKey(assetData.assetName, platform)) || map.get(assetData.assetName);
+  } else {
+    record = map.get(assetData.assetName);
+  }
+  if (!record) {
+    throw new Error(`Asset not found: ${assetPath} for platform: ${platform ?? "(unspecified)"}`);
+  }
+  return record;
+}
+async function getAbsoluteAssetInfo(assetPath, platform = null) {
+  const nameData = AssetPaths.parse(assetPath, new Set(platform != null ? [platform] : []));
+  const { name, type } = nameData;
+  const { scales, files } = await getAbsoluteAssetRecord(assetPath, platform);
+  const hasher = crypto.createHash("md5");
+  if (files.length > 0) {
+    await hashFiles(Array.from(files), hasher);
+  }
+  return { files, hash: hasher.digest("hex"), name, scales, type };
+}
+async function getAssetData(assetPath, localPath, assetDataPlugins, platform = null, publicPath) {
+  let assetUrlPath = localPath.startsWith("..") ? publicPath.replace(/\/$/, "") + "/" + path.dirname(localPath) : path.join(publicPath, path.dirname(localPath));
+  if (path.sep === "\\") {
+    assetUrlPath = assetUrlPath.replace(/\\/g, "/");
+  }
+  const isImage = isAssetTypeAnImage(path.extname(assetPath).slice(1));
+  const assetInfo = await getAbsoluteAssetInfo(assetPath, platform);
+  const isImageInput = assetInfo.files[0].includes(".zip/") ? fs.readFileSync(assetInfo.files[0]) : assetInfo.files[0];
+  const dimensions = isImage ? imageSize(isImageInput) : null;
+  const scale = assetInfo.scales[0];
+  const assetData = {
+    __packager_asset: true,
+    fileSystemLocation: path.dirname(assetPath),
+    httpServerLocation: assetUrlPath,
+    width: dimensions ? dimensions.width / scale : void 0,
+    height: dimensions ? dimensions.height / scale : void 0,
+    scales: assetInfo.scales,
+    files: assetInfo.files,
+    hash: assetInfo.hash,
+    name: assetInfo.name,
+    type: assetInfo.type
+  };
+  return await applyAssetDataPlugins(assetDataPlugins, assetData);
+}
+async function applyAssetDataPlugins(assetDataPlugins, assetData) {
+  if (!assetDataPlugins.length) {
+    return assetData;
+  }
+  const [currentAssetPlugin, ...remainingAssetPlugins] = assetDataPlugins;
+  const assetPluginFunction = require(currentAssetPlugin);
+  const resultAssetData = await assetPluginFunction(assetData);
+  return await applyAssetDataPlugins(remainingAssetPlugins, resultAssetData);
+}
+async function getAssetFiles(assetPath, platform = null) {
+  const assetData = await getAbsoluteAssetRecord(assetPath, platform);
+  return assetData.files;
+}
+async function getAsset(relativePath, projectRoot, watchFolders, platform = null, assetExts) {
+  const assetData = AssetPaths.parse(relativePath, new Set(platform != null ? [platform] : []));
+  const absolutePath = path.resolve(projectRoot, relativePath);
+  if (!assetExts.includes(assetData.type)) {
+    throw new Error(`'${relativePath}' cannot be loaded as its extension is not registered in assetExts`);
+  }
+  if (!pathBelongsToRoots(absolutePath, [projectRoot, ...watchFolders])) {
+    throw new Error(
+      `'${relativePath}' could not be found, because it cannot be found in the project root or any watch folder`
+    );
+  }
+  const record = await getAbsoluteAssetRecord(absolutePath, platform);
+  for (let i = 0; i < record.scales.length; i++) {
+    if (record.scales[i] >= assetData.resolution) {
+      return readFile(record.files[i]);
+    }
+  }
+  return readFile(record.files[record.files.length - 1]);
+}
+function pathBelongsToRoots(pathToCheck, roots) {
+  for (const rootFolder of roots) {
+    if (pathToCheck.startsWith(path.resolve(rootFolder))) {
+      return true;
+    }
+  }
+  return false;
+}
+module.exports = {
+  getAsset,
+  getAssetData,
+  getAssetFiles
+};