@lumin-monitor/react-native 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,6 +1,5 @@
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
+// src/client.ts
+import { AppState as RNAppState, Platform as RNPlatform } from "react-native";
 
 // src/ids.ts
 function uuidv4() {
@@ -18,19 +17,6 @@ function uuidv4() {
 var ANON_KEY = "lumin.anonymous_id";
 var SESSION_KEY = "lumin.session_id";
 var SESSION_LAST_SEEN_KEY = "lumin.session_last_seen";
-function detectAsyncStorage() {
-  try {
-    if (typeof __require === "undefined") return null;
-    const mod = __require("@react-native-async-storage/async-storage");
-    const candidate = mod?.default ?? mod;
-    if (candidate && typeof candidate.getItem === "function" && typeof candidate.setItem === "function") {
-      return candidate;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
 function memoryStorage() {
   const m = /* @__PURE__ */ new Map();
   return {
@@ -84,8 +70,14 @@ var DEFAULT_FLUSH_MS = 500;
 var DEFAULT_SESSION_IDLE_MS = 30 * 60 * 1e3;
 var SERVER_MAX_BATCH = 1e3;
 var DEFAULT_ENDPOINT = "https://api.getlumin.dev";
+var SDK_VERSION = "0.4.0";
 var Client = class {
   constructor(opts) {
+    this.prevErrorHandler = void 0;
+    this.errorHandlerInstalled = false;
+    // Dedup the same Error captured twice (e.g. via captureError + the global
+    // handler firing on the same throw). WeakSet so we don't pin GC.
+    this.recentErrors = /* @__PURE__ */ new WeakSet();
     this.userId = null;
     this.cachedIds = null;
     // Pending events queued before ids hydrate. `user_id` is stamped at enqueue
@@ -108,11 +100,15 @@ var Client = class {
       console.warn("[lumin] flush failed", { err, dropped });
     });
     this.fetchImpl = opts.fetch ?? fetch.bind(globalThis);
-    const resolvedStorage = opts.storage === null ? memoryStorage() : opts.storage ?? detectAsyncStorage() ?? memoryStorage();
-    this.storage = resolvedStorage;
+    this.storage = opts.storage ?? memoryStorage();
     this.appState = opts.appState === void 0 ? detectAppState() : opts.appState;
+    this.errorUtils = opts.errorUtils === void 0 ? detectErrorUtils() : opts.errorUtils;
+    this.clientHeader = buildClientHeader(opts.deviceInfo ?? null);
     this.idsReady = this.hydrateIds();
     this.installBackgroundFlush();
+    if (opts.captureUnhandledErrors !== false) {
+      this.installErrorHandler();
+    }
   }
   screen(name, properties) {
     if (this.closed) return;
@@ -130,6 +126,22 @@ var Client = class {
     }
     this.enqueue({ type: "track", name, ...properties !== void 0 ? { properties } : {} });
   }
+  captureError(err, properties) {
+    if (this.closed) return;
+    const e = normalizeError(err);
+    if (!e) return;
+    if (typeof err === "object" && err !== null) {
+      if (this.recentErrors.has(err)) return;
+      this.recentErrors.add(err);
+    }
+    this.enqueue({
+      type: "error",
+      ...properties !== void 0 ? { properties } : {},
+      error_message: e.message,
+      ...e.stack ? { error_stack: e.stack } : {},
+      ...e.type ? { error_type: e.type } : {}
+    });
+  }
   identify(userId, traits) {
     if (this.closed) return;
     if (!userId) {
@@ -166,6 +178,7 @@ var Client = class {
     if (this.closed) return;
     this.closed = true;
     this.removeBackgroundFlush();
+    this.restoreErrorHandler();
     await this.flush();
     await Promise.allSettled(this.inflight);
   }
@@ -253,13 +266,15 @@ var Client = class {
       return;
     }
     const body = JSON.stringify({ events: batch });
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: "Bearer " + this.apiKey
+    };
+    if (this.clientHeader) headers["X-Lumin-Client"] = this.clientHeader;
     try {
       const res = await this.fetchImpl(this.endpoint + "/v1/events", {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.apiKey
-        },
+        headers,
         body
       });
       if (!res.ok) {
@@ -291,24 +306,110 @@ var Client = class {
       this.appStateSub = null;
     }
   }
+  // --- error handler -----------------------------------------------------
+  /**
+   * Install a global JS error handler via ErrorUtils.setGlobalHandler that
+   * captures + chains to whatever handler was already in place. RN's
+   * red-box and any other observability tool that installed before us
+   * still fires — we do not swallow the throw.
+   */
+  installErrorHandler() {
+    if (!this.errorUtils) return;
+    this.prevErrorHandler = this.errorUtils.getGlobalHandler?.();
+    const handler = (err, isFatal) => {
+      try {
+        this.captureError(err, isFatal ? { fatal: true } : void 0);
+        if (isFatal) void this.flush();
+      } catch {
+      }
+      if (this.prevErrorHandler) {
+        this.prevErrorHandler(err, isFatal);
+      }
+    };
+    this.errorUtils.setGlobalHandler(handler);
+    this.errorHandlerInstalled = true;
+  }
+  restoreErrorHandler() {
+    if (!this.errorHandlerInstalled || !this.errorUtils) return;
+    this.errorUtils.setGlobalHandler(
+      this.prevErrorHandler ?? defaultNoopErrorHandler
+    );
+    this.errorHandlerInstalled = false;
+  }
 };
+function defaultNoopErrorHandler() {
+}
+function detectErrorUtils() {
+  const g = globalThis;
+  const eu = g.ErrorUtils;
+  if (eu && typeof eu.setGlobalHandler === "function") {
+    return eu;
+  }
+  return null;
+}
+function normalizeError(raw) {
+  if (raw == null) return null;
+  if (raw instanceof Error) {
+    return {
+      message: raw.message || raw.name || "Error",
+      ...raw.stack ? { stack: raw.stack } : {},
+      type: raw.name || raw.constructor?.name
+    };
+  }
+  if (typeof raw === "string") {
+    return { message: raw };
+  }
+  if (typeof raw === "object") {
+    const obj = raw;
+    const message = typeof obj.message === "string" ? obj.message : safeStringify(raw);
+    return {
+      message,
+      ...typeof obj.stack === "string" ? { stack: obj.stack } : {},
+      ...typeof obj.name === "string" ? { type: obj.name } : {}
+    };
+  }
+  return { message: String(raw) };
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
 function clampBatch(n) {
   if (!Number.isFinite(n) || n < 1) return 1;
   if (n > SERVER_MAX_BATCH) return SERVER_MAX_BATCH;
   return Math.floor(n);
 }
-function detectAppState() {
-  try {
-    if (typeof __require === "undefined") return null;
-    const rn = __require("react-native");
-    const candidate = rn?.AppState;
-    if (candidate && typeof candidate.addEventListener === "function") {
-      return candidate;
+function buildClientHeader(deviceInfo) {
+  const parts = [`sdk=rn/${SDK_VERSION}`];
+  const platform = RNPlatform;
+  const osRaw = platform?.OS;
+  if (typeof osRaw === "string" && osRaw) {
+    parts.push(`os=${encodeURIComponent(osRaw)}`);
+  } else {
+    return "";
+  }
+  const versionRaw = platform?.Version;
+  if (versionRaw !== void 0 && versionRaw !== null && versionRaw !== "") {
+    parts.push(`os_version=${encodeURIComponent(String(versionRaw))}`);
+  }
+  if (deviceInfo && typeof deviceInfo.getModel === "function") {
+    try {
+      const model = deviceInfo.getModel();
+      if (model) parts.push(`device=${encodeURIComponent(model)}`);
+    } catch {
     }
-    return null;
-  } catch {
-    return null;
   }
+  return parts.join("; ");
+}
+function detectAppState() {
+  const candidate = RNAppState;
+  if (candidate && typeof candidate.addEventListener === "function") {
+    return candidate;
+  }
+  return null;
 }
 function validateEndpoint(raw) {
   let url;
@@ -346,6 +447,7 @@ function init(opts) {
     screen: c.screen.bind(c),
     track: c.track.bind(c),
     identify: c.identify.bind(c),
+    captureError: c.captureError.bind(c),
     flush: c.flush.bind(c),
     close: c.close.bind(c),
     getSessionId: c.getSessionId.bind(c),

package/dist/react-navigation.d.cts

@@ -1,4 +1,4 @@
-import { L as LuminClient } from './types-BeHbtR1J.cjs';
+import { L as LuminClient } from './types-B6rqS9Vp.cjs';
 
 /**
  * Subset of @react-navigation/native's NavigationContainerRef the hook needs.

package/dist/react-navigation.d.ts

@@ -1,4 +1,4 @@
-import { L as LuminClient } from './types-BeHbtR1J.js';
+import { L as LuminClient } from './types-B6rqS9Vp.js';
 
 /**
  * Subset of @react-navigation/native's NavigationContainerRef the hook needs.

package/dist/react-navigation.js

@@ -1,5 +1,3 @@
-import "./chunk-3RG5ZIWI.js";
-
 // src/react-navigation.ts
 import { useEffect, useRef } from "react";
 function useLuminScreenviews(client, navigationRef) {

package/dist/types-B6rqS9Vp.d.cts

@@ -0,0 +1,169 @@
+type EventType = "page" | "track" | "identify" | "error";
+interface WireEvent {
+    ts?: number;
+    session_id: string;
+    anonymous_id?: string;
+    user_id?: string;
+    type: EventType;
+    name?: string;
+    url?: string;
+    referrer?: string;
+    properties?: Record<string, unknown>;
+    trace_id?: string;
+    error_message?: string;
+    error_stack?: string;
+    error_type?: string;
+}
+/**
+ * Minimal AsyncStorage shape the SDK actually consumes. Matches both
+ * @react-native-async-storage/async-storage (community) and the legacy
+ * react-native built-in. Apps that ship a different storage backend can
+ * implement this directly.
+ */
+interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem?(key: string): Promise<void>;
+}
+interface InitOptions {
+    /** API key minted in the Lumin UI (settings → API keys). Must be `lmn_pub_*`. */
+    apiKey: string;
+    /**
+     * Base URL of the Lumin ingest endpoint. Defaults to
+     * `https://api.getlumin.dev`. Override only for local development against
+     * a Lumin instance you are running yourself or for a customer-side
+     * same-origin proxy.
+     *
+     * Validation: must parse as a valid URL with no path beyond `/`. `https://`
+     * is required except when the hostname is `localhost`, `127.0.0.1`, or a
+     * `.localhost` subdomain (where `http://` is allowed). Invalid shapes
+     * throw synchronously from `init()` so misconfigurations surface at boot.
+     */
+    endpoint?: string;
+    /** Max events to buffer before forcing a flush. Default 50. */
+    batchSize?: number;
+    /** Max ms between flushes. Default 500. */
+    flushIntervalMs?: number;
+    /**
+     * Session idle timeout. A new session_id is minted on the next event if
+     * the time since the last event exceeds this value. Default 30 min
+     * (matches the industry-standard analytics convention).
+     */
+    sessionIdleMs?: number;
+    /**
+     * Optional error sink. Called with the failed batch + reason so apps can
+     * surface drops. Default: console.warn.
+     */
+    onError?: (err: unknown, dropped: number) => void;
+    /**
+     * Override the global fetch. Tests use this to capture requests without
+     * spinning up a network stub.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Storage backend for the persistent `anonymous_id` and `session_id`.
+     * Pass `AsyncStorage` from `@react-native-async-storage/async-storage`
+     * (recommended) or any object satisfying `AsyncStorageLike`. Omit /
+     * pass `null` for ephemeral in-memory ids that reset on every cold
+     * start.
+     *
+     * The SDK no longer auto-detects AsyncStorage as of 0.3.0 — the
+     * runtime require broke Metro bundling, and forcing every consumer
+     * to install an unused peer dep was the wrong trade. See CHANGELOG.
+     *
+     * ```ts
+     * import AsyncStorage from "@react-native-async-storage/async-storage";
+     * init({ apiKey, storage: AsyncStorage });
+     * ```
+     */
+    storage?: AsyncStorageLike | null;
+    /**
+     * Override the React Native AppState module. Defaults to `react-native`'s
+     * AppState; tests pass a stub.
+     */
+    appState?: AppStateLike | null;
+    /**
+     * Auto-capture unhandled JS errors via ErrorUtils.setGlobalHandler.
+     * Default true. Set false to disable (e.g. when another tool like Sentry
+     * already owns the global handler). When enabled, the SDK chains to any
+     * previously installed handler so RN's red-box and other reporters
+     * still fire.
+     *
+     * Native crashes (iOS / Android) are NOT captured — that requires native
+     * modules outside this SDK's scope.
+     */
+    captureUnhandledErrors?: boolean;
+    /**
+     * Override the global ErrorUtils-like object the SDK installs into.
+     * The SDK auto-detects React Native's ErrorUtils on globalThis at
+     * runtime; tests pass a stub.
+     */
+    errorUtils?: ErrorUtilsLike | null;
+    /**
+     * Optional `react-native-device-info` instance (or any object satisfying
+     * `DeviceInfoLike`). When passed, the SDK adds `device=<model>` to the
+     * `X-Lumin-Client` header so the server can surface the device model in
+     * the sessions UI.
+     *
+     * Not auto-detected — passing it is opt-in, matching the `storage`
+     * pattern. The SDK never `require()`s the package, which keeps Metro
+     * bundling clean.
+     *
+     * ```ts
+     * import DeviceInfo from "react-native-device-info";
+     * init({ apiKey, deviceInfo: DeviceInfo });
+     * ```
+     */
+    deviceInfo?: DeviceInfoLike | null;
+}
+/**
+ * Minimal shape of React Native's ErrorUtils. The SDK uses these three
+ * methods to chain into any previously installed handler.
+ */
+interface ErrorUtilsLike {
+    setGlobalHandler(handler: (err: unknown, isFatal?: boolean) => void): void;
+    getGlobalHandler?(): ((err: unknown, isFatal?: boolean) => void) | undefined;
+}
+/**
+ * Minimal shape the SDK consumes from `react-native-device-info` (or any
+ * compatible shim). Structural so we don't pull react-native-device-info
+ * types into the SDK's public surface — the app already has them. Only
+ * `getModel` is required; future fields can be added the same way.
+ *
+ * Passed via `init({ deviceInfo: DeviceInfo })`. If omitted, the SDK still
+ * reports `os` + `os_version` from React Native's `Platform` constants —
+ * device model is the only thing that needs the optional peer dep.
+ */
+interface DeviceInfoLike {
+    getModel(): string;
+}
+/**
+ * Minimal AppState shape the SDK consumes (subset of react-native's AppState).
+ * The SDK auto-detects `react-native` at runtime; pass this only for tests or
+ * non-RN environments.
+ */
+interface AppStateLike {
+    addEventListener(type: "change", listener: (state: string) => void): {
+        remove: () => void;
+    };
+}
+interface LuminClient {
+    screen(name?: string, properties?: Record<string, unknown>): void;
+    track(name: string, properties?: Record<string, unknown>): void;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    /**
+     * Capture an error. Accepts a real Error (preferred — preserves stack +
+     * constructor name as error_type), or any value that will be stringified
+     * for error_message. `properties` is forwarded verbatim so callers can
+     * attach context (route, user action, request id).
+     */
+    captureError(err: unknown, properties?: Record<string, unknown>): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    /** Current session id. Resolves once AsyncStorage hydration finishes. */
+    getSessionId(): Promise<string>;
+    /** Current anonymous id. Resolves once AsyncStorage hydration finishes. */
+    getAnonymousId(): Promise<string>;
+}
+
+export type { AppStateLike as A, DeviceInfoLike as D, ErrorUtilsLike as E, InitOptions as I, LuminClient as L, WireEvent as W, AsyncStorageLike as a, EventType as b };

package/dist/types-B6rqS9Vp.d.ts

@@ -0,0 +1,169 @@
+type EventType = "page" | "track" | "identify" | "error";
+interface WireEvent {
+    ts?: number;
+    session_id: string;
+    anonymous_id?: string;
+    user_id?: string;
+    type: EventType;
+    name?: string;
+    url?: string;
+    referrer?: string;
+    properties?: Record<string, unknown>;
+    trace_id?: string;
+    error_message?: string;
+    error_stack?: string;
+    error_type?: string;
+}
+/**
+ * Minimal AsyncStorage shape the SDK actually consumes. Matches both
+ * @react-native-async-storage/async-storage (community) and the legacy
+ * react-native built-in. Apps that ship a different storage backend can
+ * implement this directly.
+ */
+interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem?(key: string): Promise<void>;
+}
+interface InitOptions {
+    /** API key minted in the Lumin UI (settings → API keys). Must be `lmn_pub_*`. */
+    apiKey: string;
+    /**
+     * Base URL of the Lumin ingest endpoint. Defaults to
+     * `https://api.getlumin.dev`. Override only for local development against
+     * a Lumin instance you are running yourself or for a customer-side
+     * same-origin proxy.
+     *
+     * Validation: must parse as a valid URL with no path beyond `/`. `https://`
+     * is required except when the hostname is `localhost`, `127.0.0.1`, or a
+     * `.localhost` subdomain (where `http://` is allowed). Invalid shapes
+     * throw synchronously from `init()` so misconfigurations surface at boot.
+     */
+    endpoint?: string;
+    /** Max events to buffer before forcing a flush. Default 50. */
+    batchSize?: number;
+    /** Max ms between flushes. Default 500. */
+    flushIntervalMs?: number;
+    /**
+     * Session idle timeout. A new session_id is minted on the next event if
+     * the time since the last event exceeds this value. Default 30 min
+     * (matches the industry-standard analytics convention).
+     */
+    sessionIdleMs?: number;
+    /**
+     * Optional error sink. Called with the failed batch + reason so apps can
+     * surface drops. Default: console.warn.
+     */
+    onError?: (err: unknown, dropped: number) => void;
+    /**
+     * Override the global fetch. Tests use this to capture requests without
+     * spinning up a network stub.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Storage backend for the persistent `anonymous_id` and `session_id`.
+     * Pass `AsyncStorage` from `@react-native-async-storage/async-storage`
+     * (recommended) or any object satisfying `AsyncStorageLike`. Omit /
+     * pass `null` for ephemeral in-memory ids that reset on every cold
+     * start.
+     *
+     * The SDK no longer auto-detects AsyncStorage as of 0.3.0 — the
+     * runtime require broke Metro bundling, and forcing every consumer
+     * to install an unused peer dep was the wrong trade. See CHANGELOG.
+     *
+     * ```ts
+     * import AsyncStorage from "@react-native-async-storage/async-storage";
+     * init({ apiKey, storage: AsyncStorage });
+     * ```
+     */
+    storage?: AsyncStorageLike | null;
+    /**
+     * Override the React Native AppState module. Defaults to `react-native`'s
+     * AppState; tests pass a stub.
+     */
+    appState?: AppStateLike | null;
+    /**
+     * Auto-capture unhandled JS errors via ErrorUtils.setGlobalHandler.
+     * Default true. Set false to disable (e.g. when another tool like Sentry
+     * already owns the global handler). When enabled, the SDK chains to any
+     * previously installed handler so RN's red-box and other reporters
+     * still fire.
+     *
+     * Native crashes (iOS / Android) are NOT captured — that requires native
+     * modules outside this SDK's scope.
+     */
+    captureUnhandledErrors?: boolean;
+    /**
+     * Override the global ErrorUtils-like object the SDK installs into.
+     * The SDK auto-detects React Native's ErrorUtils on globalThis at
+     * runtime; tests pass a stub.
+     */
+    errorUtils?: ErrorUtilsLike | null;
+    /**
+     * Optional `react-native-device-info` instance (or any object satisfying
+     * `DeviceInfoLike`). When passed, the SDK adds `device=<model>` to the
+     * `X-Lumin-Client` header so the server can surface the device model in
+     * the sessions UI.
+     *
+     * Not auto-detected — passing it is opt-in, matching the `storage`
+     * pattern. The SDK never `require()`s the package, which keeps Metro
+     * bundling clean.
+     *
+     * ```ts
+     * import DeviceInfo from "react-native-device-info";
+     * init({ apiKey, deviceInfo: DeviceInfo });
+     * ```
+     */
+    deviceInfo?: DeviceInfoLike | null;
+}
+/**
+ * Minimal shape of React Native's ErrorUtils. The SDK uses these three
+ * methods to chain into any previously installed handler.
+ */
+interface ErrorUtilsLike {
+    setGlobalHandler(handler: (err: unknown, isFatal?: boolean) => void): void;
+    getGlobalHandler?(): ((err: unknown, isFatal?: boolean) => void) | undefined;
+}
+/**
+ * Minimal shape the SDK consumes from `react-native-device-info` (or any
+ * compatible shim). Structural so we don't pull react-native-device-info
+ * types into the SDK's public surface — the app already has them. Only
+ * `getModel` is required; future fields can be added the same way.
+ *
+ * Passed via `init({ deviceInfo: DeviceInfo })`. If omitted, the SDK still
+ * reports `os` + `os_version` from React Native's `Platform` constants —
+ * device model is the only thing that needs the optional peer dep.
+ */
+interface DeviceInfoLike {
+    getModel(): string;
+}
+/**
+ * Minimal AppState shape the SDK consumes (subset of react-native's AppState).
+ * The SDK auto-detects `react-native` at runtime; pass this only for tests or
+ * non-RN environments.
+ */
+interface AppStateLike {
+    addEventListener(type: "change", listener: (state: string) => void): {
+        remove: () => void;
+    };
+}
+interface LuminClient {
+    screen(name?: string, properties?: Record<string, unknown>): void;
+    track(name: string, properties?: Record<string, unknown>): void;
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    /**
+     * Capture an error. Accepts a real Error (preferred — preserves stack +
+     * constructor name as error_type), or any value that will be stringified
+     * for error_message. `properties` is forwarded verbatim so callers can
+     * attach context (route, user action, request id).
+     */
+    captureError(err: unknown, properties?: Record<string, unknown>): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    /** Current session id. Resolves once AsyncStorage hydration finishes. */
+    getSessionId(): Promise<string>;
+    /** Current anonymous id. Resolves once AsyncStorage hydration finishes. */
+    getAnonymousId(): Promise<string>;
+}
+
+export type { AppStateLike as A, DeviceInfoLike as D, ErrorUtilsLike as E, InitOptions as I, LuminClient as L, WireEvent as W, AsyncStorageLike as a, EventType as b };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumin-monitor/react-native",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "React Native SDK for Lumin: screen / track / identify with batched ingest.",
   "keywords": [
     "lumin",
@@ -50,18 +50,15 @@
   "files": [
     "dist",
     "LICENSE",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "@react-native-async-storage/async-storage": ">=1.21.0",
     "@react-navigation/native": ">=6",
     "react": ">=18",
     "react-native": ">=0.72"
   },
   "peerDependenciesMeta": {
-    "@react-native-async-storage/async-storage": {
-      "optional": true
-    },
     "@react-navigation/native": {
       "optional": true
     }

package/dist/chunk-3RG5ZIWI.js

@@ -1,10 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};