@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-6VQEXLE2.mjs

@@ -0,0 +1,144 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  startCallbackServer
+} from "./chunk-2NAP2ZF7.mjs";
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/cli/auth-flow.ts
+var auth_flow_exports = {};
+__export(auth_flow_exports, {
+  AUTH_POLL_INTERVAL_MS: () => AUTH_POLL_INTERVAL_MS,
+  AUTH_PROVIDERS: () => AUTH_PROVIDERS,
+  AUTH_PROVIDER_LABELS: () => AUTH_PROVIDER_LABELS,
+  RELAY_CALLBACK_TIMEOUT_MS: () => RELAY_CALLBACK_TIMEOUT_MS,
+  browserLaunchCommand: () => browserLaunchCommand,
+  daemonIsLocal: () => daemonIsLocal,
+  loginChatGpt: () => loginChatGpt,
+  loginGrok: () => loginGrok,
+  normalizeAuthProvider: () => normalizeAuthProvider,
+  openBrowser: () => openBrowser,
+  waitForAuth: () => waitForAuth
+});
+import { spawn as nodeSpawn } from "child_process";
+var AUTH_PROVIDERS = ["chatgpt", "grok"], AUTH_PROVIDER_LABELS = {
+  chatgpt: "ChatGPT",
+  grok: "Grok"
+}, RELAY_CALLBACK_TIMEOUT_MS = 300 * 1e3, AUTH_POLL_INTERVAL_MS = 2e3, LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function normalizeAuthProvider(value) {
+  switch (value?.toLowerCase()) {
+    case "chatgpt":
+    case "openai":
+    case "codex":
+      return "chatgpt";
+    case "grok":
+    case "xai":
+      return "grok";
+    default:
+      return null;
+  }
+}
+function daemonIsLocal(daemonUrl) {
+  try {
+    return LOOPBACK_HOSTS.has(new URL(daemonUrl).hostname);
+  } catch {
+    return !1;
+  }
+}
+function browserLaunchCommand(url, platform = process.platform) {
+  return platform === "win32" ? { command: "rundll32", args: ["url.dll,FileProtocolHandler", url] } : platform === "darwin" ? { command: "open", args: [url] } : { command: "xdg-open", args: [url] };
+}
+function openBrowser(url, deps = {}) {
+  let { command, args } = browserLaunchCommand(url, deps.platform);
+  try {
+    let child = (deps.spawn ?? nodeSpawn)(command, args, { detached: !0, stdio: "ignore", windowsHide: !0 });
+    child.on("error", () => {
+    }), child.unref();
+  } catch {
+  }
+}
+var CANCELLED = { ok: !1, error: "Sign-in cancelled", cancelled: !0 };
+function isRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    let timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer), signal?.removeEventListener("abort", done), resolve();
+    }
+    signal?.addEventListener("abort", done, { once: !0 });
+  });
+}
+async function loginChatGpt(deps, opts) {
+  let relay = opts.mode === "relay" ? !0 : opts.mode === "loopback" ? !1 : !daemonIsLocal(opts.daemonUrl), open = deps.openBrowser ?? openBrowser;
+  if (!relay) {
+    let data = await deps.request("POST", "/auth/chatgpt/start", { mode: "loopback" }), authUrl = isRecord(data) && typeof data.authUrl == "string" ? data.authUrl : "";
+    return opts.onStart({ mode: "loopback", authUrl, raw: data }), deps.signal?.aborted ? CANCELLED : (authUrl && open(authUrl), waitForAuth(deps, "chatgpt", RELAY_CALLBACK_TIMEOUT_MS));
+  }
+  let server = await (deps.startCallbackServer ?? (() => startCallbackServer(RELAY_CALLBACK_TIMEOUT_MS)))();
+  try {
+    let redirectUri = `http://localhost:${server.port}/auth/callback`, started = await deps.request("POST", "/auth/chatgpt/start", { mode: "relay", redirectUri });
+    if (!isRecord(started) || typeof started.flowId != "string" || typeof started.authUrl != "string")
+      throw new Error("Daemon did not return a relay auth flow \u2014 it may be running an older build");
+    if (opts.onStart({ mode: "relay", authUrl: started.authUrl, redirectUri, raw: started }), deps.signal?.aborted) return CANCELLED;
+    open(started.authUrl);
+    let callback = await raceAbort(server.waitForCallback(), deps.signal);
+    if (!callback) return CANCELLED;
+    let done = await deps.request("POST", "/auth/chatgpt/complete", { flowId: started.flowId, code: callback.code, state: callback.state }), status = isRecord(done) && isRecord(done.status) ? done.status : {};
+    return { ok: !0, email: typeof status.email == "string" ? status.email : void 0, raw: done };
+  } finally {
+    server.close();
+  }
+}
+async function loginGrok(deps, opts) {
+  let data = await deps.request("POST", "/auth/grok/start");
+  if (!isRecord(data)) throw new Error("Unexpected response from /auth/grok/start");
+  let userCode = typeof data.userCode == "string" ? data.userCode : "", verificationUri = typeof data.verificationUriComplete == "string" && data.verificationUriComplete ? data.verificationUriComplete : typeof data.verificationUri == "string" ? data.verificationUri : "", expiresInSec = typeof data.expiresIn == "number" && data.expiresIn > 0 ? data.expiresIn : 900;
+  return opts.onStart({ userCode, verificationUri, expiresInSec, raw: data }), deps.signal?.aborted ? CANCELLED : (verificationUri && (deps.openBrowser ?? openBrowser)(verificationUri), waitForAuth(deps, "grok", expiresInSec * 1e3));
+}
+async function waitForAuth(deps, provider, timeoutMs) {
+  let sleep = deps.sleep ?? ((ms) => abortableSleep(ms, deps.signal)), deadline = Date.now() + timeoutMs;
+  for (; Date.now() < deadline; ) {
+    if (await sleep(AUTH_POLL_INTERVAL_MS), deps.signal?.aborted) return CANCELLED;
+    let status = await deps.request("GET", `/auth/${provider}/status`);
+    if (deps.signal?.aborted) return CANCELLED;
+    if (isRecord(status)) {
+      if (status.authenticated === !0) return { ok: !0, email: typeof status.email == "string" ? status.email : void 0, raw: status };
+      if (typeof status.flowError == "string" && status.flowError) return { ok: !1, error: status.flowError };
+    }
+  }
+  return { ok: !1, error: `Timed out waiting for ${AUTH_PROVIDER_LABELS[provider]} sign-in`, timedOut: !0 };
+}
+async function raceAbort(promise, signal) {
+  return signal ? signal.aborted ? null : new Promise((resolve, reject) => {
+    let onAbort = () => resolve(null);
+    signal.addEventListener("abort", onAbort, { once: !0 }), promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort), resolve(value);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort), signal.aborted ? resolve(null) : reject(err);
+      }
+    );
+  }) : promise;
+}
+
+export {
+  AUTH_PROVIDER_LABELS,
+  normalizeAuthProvider,
+  openBrowser,
+  loginChatGpt,
+  loginGrok,
+  auth_flow_exports
+};

package/dist/chunks/chunk-6XUV6EK6.mjs

@@ -0,0 +1,41 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_extension,
+  require_permessage_deflate,
+  require_receiver,
+  require_sender,
+  require_stream,
+  require_subprotocol,
+  require_websocket,
+  require_websocket_server
+} from "./chunk-NGK6PVSF.mjs";
+import {
+  __commonJS
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/ws/index.js
+var require_ws = __commonJS({
+  "node_modules/ws/index.js"(exports, module) {
+    "use strict";
+    var createWebSocketStream = require_stream(), extension = require_extension(), PerMessageDeflate = require_permessage_deflate(), Receiver = require_receiver(), Sender = require_sender(), subprotocol = require_subprotocol(), WebSocket = require_websocket(), WebSocketServer = require_websocket_server();
+    WebSocket.createWebSocketStream = createWebSocketStream;
+    WebSocket.extension = extension;
+    WebSocket.PerMessageDeflate = PerMessageDeflate;
+    WebSocket.Receiver = Receiver;
+    WebSocket.Sender = Sender;
+    WebSocket.Server = WebSocketServer;
+    WebSocket.subprotocol = subprotocol;
+    WebSocket.WebSocket = WebSocket;
+    WebSocket.WebSocketServer = WebSocketServer;
+    module.exports = WebSocket;
+  }
+});
+
+export {
+  require_ws
+};

package/dist/chunks/chunk-776TSXEP.mjs

@@ -0,0 +1,43 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  nanoid
+} from "./chunk-3GNIDM53.mjs";
+
+// src/main/adapters/shared/audio-convert.ts
+import { execFile } from "child_process";
+import { promises as fsp } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+async function convertToOggOpus(input) {
+  let id = nanoid(8), inPath = join(tmpdir(), `adf_audio_in_${id}`), outPath = join(tmpdir(), `adf_audio_out_${id}.ogg`);
+  try {
+    return await fsp.writeFile(inPath, input), await new Promise((resolve, reject) => {
+      execFile("ffmpeg", [
+        "-i",
+        inPath,
+        "-c:a",
+        "libopus",
+        "-b:a",
+        "64k",
+        "-vn",
+        "-y",
+        outPath
+      ], (error) => {
+        error ? reject(new Error(`ffmpeg conversion failed: ${error.message}. Is ffmpeg installed?`)) : resolve();
+      });
+    }), await fsp.readFile(outPath);
+  } finally {
+    await fsp.unlink(inPath).catch(() => {
+    }), await fsp.unlink(outPath).catch(() => {
+    });
+  }
+}
+
+export {
+  convertToOggOpus
+};

package/dist/chunks/chunk-7CV2SA3H.mjs

@@ -0,0 +1,285 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_react
+} from "./chunk-6GJ4QHRI.mjs";
+import {
+  __commonJS
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/react/cjs/react-jsx-runtime.production.js
+var require_react_jsx_runtime_production = __commonJS({
+  "node_modules/react/cjs/react-jsx-runtime.production.js"(exports) {
+    "use strict";
+    var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+    function jsxProd(type, config, maybeKey) {
+      var key = null;
+      if (maybeKey !== void 0 && (key = "" + maybeKey), config.key !== void 0 && (key = "" + config.key), "key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          propName !== "key" && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      return config = maybeKey.ref, {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        ref: config !== void 0 ? config : null,
+        props: maybeKey
+      };
+    }
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsx = jsxProd;
+    exports.jsxs = jsxProd;
+  }
+});
+
+// node_modules/react/cjs/react-jsx-runtime.development.js
+var require_react_jsx_runtime_development = __commonJS({
+  "node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
+    "use strict";
+    process.env.NODE_ENV !== "production" && (function() {
+      function getComponentNameFromType(type) {
+        if (type == null) return null;
+        if (typeof type == "function")
+          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+        if (typeof type == "string") return type;
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+          case REACT_ACTIVITY_TYPE:
+            return "Activity";
+        }
+        if (typeof type == "object")
+          switch (typeof type.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), type.$$typeof) {
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case REACT_CONTEXT_TYPE:
+              return type.displayName || "Context";
+            case REACT_CONSUMER_TYPE:
+              return (type._context.displayName || "Context") + ".Consumer";
+            case REACT_FORWARD_REF_TYPE:
+              var innerType = type.render;
+              return type = type.displayName, type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef"), type;
+            case REACT_MEMO_TYPE:
+              return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE:
+              innerType = type._payload, type = type._init;
+              try {
+                return getComponentNameFromType(type(innerType));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        try {
+          testStringCoercion(value);
+          var JSCompiler_inline_result = !1;
+        } catch {
+          JSCompiler_inline_result = !0;
+        }
+        if (JSCompiler_inline_result) {
+          JSCompiler_inline_result = console;
+          var JSCompiler_temp_const = JSCompiler_inline_result.error, JSCompiler_inline_result$jscomp$0 = typeof Symbol == "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          return JSCompiler_temp_const.call(
+            JSCompiler_inline_result,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            JSCompiler_inline_result$jscomp$0
+          ), testStringCoercion(value);
+        }
+      }
+      function getTaskName(type) {
+        if (type === REACT_FRAGMENT_TYPE) return "<>";
+        if (typeof type == "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+          return "<...>";
+        try {
+          var name = getComponentNameFromType(type);
+          return name ? "<" + name + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function getOwner() {
+        var dispatcher = ReactSharedInternals.A;
+        return dispatcher === null ? null : dispatcher.getOwner();
+      }
+      function UnknownOwner() {
+        return Error("react-stack-top-frame");
+      }
+      function hasValidKey(config) {
+        if (hasOwnProperty.call(config, "key")) {
+          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+          if (getter && getter.isReactWarning) return !1;
+        }
+        return config.key !== void 0;
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        function warnAboutAccessingKey() {
+          specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            displayName
+          ));
+        }
+        warnAboutAccessingKey.isReactWarning = !0, Object.defineProperty(props, "key", {
+          get: warnAboutAccessingKey,
+          configurable: !0
+        });
+      }
+      function elementRefGetterWithDeprecationWarning() {
+        var componentName = getComponentNameFromType(this.type);
+        return didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), componentName = this.props.ref, componentName !== void 0 ? componentName : null;
+      }
+      function ReactElement(type, key, props, owner, debugStack, debugTask) {
+        var refProp = props.ref;
+        return type = {
+          $$typeof: REACT_ELEMENT_TYPE,
+          type,
+          key,
+          props,
+          _owner: owner
+        }, (refProp !== void 0 ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+          enumerable: !1,
+          get: elementRefGetterWithDeprecationWarning
+        }) : Object.defineProperty(type, "ref", { enumerable: !1, value: null }), type._store = {}, Object.defineProperty(type._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(type, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(type, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: debugStack
+        }), Object.defineProperty(type, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: debugTask
+        }), Object.freeze && (Object.freeze(type.props), Object.freeze(type)), type;
+      }
+      function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+        var children = config.children;
+        if (children !== void 0)
+          if (isStaticChildren)
+            if (isArrayImpl(children)) {
+              for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+                validateChildKeys(children[isStaticChildren]);
+              Object.freeze && Object.freeze(children);
+            } else
+              console.error(
+                "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+              );
+          else validateChildKeys(children);
+        if (hasOwnProperty.call(config, "key")) {
+          children = getComponentNameFromType(type);
+          var keys = Object.keys(config).filter(function(k) {
+            return k !== "key";
+          });
+          isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}", didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+            `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+            isStaticChildren,
+            children,
+            keys,
+            children
+          ), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+        }
+        if (children = null, maybeKey !== void 0 && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey), hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key), "key" in config) {
+          maybeKey = {};
+          for (var propName in config)
+            propName !== "key" && (maybeKey[propName] = config[propName]);
+        } else maybeKey = config;
+        return children && defineKeyPropWarningGetter(
+          maybeKey,
+          typeof type == "function" ? type.displayName || type.name || "Unknown" : type
+        ), ReactElement(
+          type,
+          children,
+          maybeKey,
+          getOwner(),
+          debugStack,
+          debugTask
+        );
+      }
+      function validateChildKeys(node) {
+        isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node == "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+      }
+      function isValidElement(object) {
+        return typeof object == "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      var React = require_react(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      React = {
+        react_stack_bottom_frame: function(callStackForError) {
+          return callStackForError();
+        }
+      };
+      var specialPropKeyWarningShown, didWarnAboutElementRef = {}, unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+        React,
+        UnknownOwner
+      )(), unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner)), didWarnAboutKeySpread = {};
+      exports.Fragment = REACT_FRAGMENT_TYPE, exports.jsx = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          !1,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      }, exports.jsxs = function(type, config, maybeKey) {
+        var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return jsxDEVImpl(
+          type,
+          config,
+          maybeKey,
+          !0,
+          trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      };
+    })();
+  }
+});
+
+// node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS({
+  "node_modules/react/jsx-runtime.js"(exports, module) {
+    "use strict";
+    process.env.NODE_ENV === "production" ? module.exports = require_react_jsx_runtime_production() : module.exports = require_react_jsx_runtime_development();
+  }
+});
+
+export {
+  require_jsx_runtime
+};