"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";

// src/nats/nats.ts
function assertClientSide() {
  if (typeof window === "undefined") {
    throw new Error("NATS client can only connect from the browser/runtime with WebSocket support (window is undefined).");
  }
}
async function importNats() {
  return await Promise.resolve().then(() => _interopRequireWildcard(require("nats.ws")));
}
function toNatsHeaders(nats, init) {
  if (!init) return void 0;
  if (typeof init.get === "function") return init;
  const h = nats.headers();
  for (const [k, v] of Object.entries(init)) {
    if (v !== void 0 && v !== null) h.set(k, String(v));
  }
  return h;
}
function cryptoRandom() {
  const buf = new Uint32Array(1);
  crypto.getRandomValues(buf);
  return buf[0] / (4294967295 + 1);
}
function createExponentialBackoffHandler(opts) {
  const initialDelay = _nullishCoalesce(opts.initialDelayMs, () => ( 1e3));
  const maxDelay = _nullishCoalesce(opts.maxDelayMs, () => ( 3e4));
  const multiplier = _nullishCoalesce(opts.multiplier, () => ( 2));
  const jitter = _nullishCoalesce(opts.jitter, () => ( true));
  let attempt = 0;
  return {
    handler: () => {
      const delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
      attempt++;
      return jitter ? delay * (0.5 + cryptoRandom() * 0.5) : delay;
    },
    reset: () => {
      attempt = 0;
    }
  };
}
function mapOptionsToConnectionOptions(opts, backoff) {
  return {
    servers: opts.servers,
    name: opts.name,
    token: opts.token,
    user: opts.user,
    pass: opts.pass,
    timeout: _nullishCoalesce(opts.connectTimeoutMs, () => ( 15e3)),
    reconnect: _nullishCoalesce(opts.reconnect, () => ( true)),
    maxReconnectAttempts: opts.maxReconnectAttempts,
    reconnectTimeWait: opts.reconnectTimeWaitMs,
    reconnectDelayHandler: _optionalChain([backoff, 'optionalAccess', _ => _.handler]),
    pingInterval: opts.pingIntervalMs,
    maxPingOut: opts.maxPingOut,
    inboxPrefix: opts.inboxPrefix
  };
}
function mapNatsTypeToStatus(type) {
  const t = String(type).toLowerCase();
  if (t.includes("disconnect")) return "disconnected";
  if (t === "reconnecting") return "reconnecting";
  if (t === "reconnect" || t.includes("connect")) return "connected";
  if (t.includes("error")) return "error";
  if (t.includes("close")) return "closed";
  return null;
}
function createNatsClient(options) {
  let nc = null;
  let statusLoopAbort = null;
  let connectInFlight = null;
  const backoff = options.exponentialBackoff ? createExponentialBackoffHandler(options.exponentialBackoff) : void 0;
  const statusListeners = /* @__PURE__ */ new Set();
  function emitStatus(event) {
    for (const listener of statusListeners) {
      try {
        listener(event);
      } catch (e2) {
      }
    }
  }
  async function connect() {
    if (nc && !nc.isClosed()) return;
    if (connectInFlight) return connectInFlight;
    assertClientSide();
    connectInFlight = (async () => {
      try {
        emitStatus({ status: "connecting" });
        const nats = await importNats();
        const conn = await nats.connect(mapOptionsToConnectionOptions(options, backoff));
        nc = conn;
        emitStatus({ status: "connected" });
        statusLoopAbort = new AbortController();
        const signal = statusLoopAbort.signal;
        (async () => {
          try {
            for await (const s of conn.status()) {
              if (signal.aborted) return;
              const mapped = mapNatsTypeToStatus(_optionalChain([s, 'optionalAccess', _2 => _2.type]));
              if (mapped) {
                if (mapped === "connected" && backoff) {
                  backoff.reset();
                }
                emitStatus({ status: mapped, data: _optionalChain([s, 'optionalAccess', _3 => _3.data]) });
                if (mapped === "closed") {
                  nc = null;
                }
              }
            }
          } catch (e) {
            if (!signal.aborted) {
              emitStatus({ status: "error", data: e });
              nc = null;
            }
          }
        })().catch(() => {
        });
      } finally {
        connectInFlight = null;
      }
    })();
    return connectInFlight;
  }
  async function close() {
    const conn = nc;
    nc = null;
    if (statusLoopAbort) {
      try {
        statusLoopAbort.abort();
      } catch (e3) {
      }
      statusLoopAbort = null;
    }
    if (!conn) return;
    try {
      await conn.drain();
    } finally {
      try {
        await conn.close();
      } finally {
        emitStatus({ status: "closed" });
      }
    }
  }
  function requireConnection() {
    if (!nc) throw new Error("NATS is not connected. Call client.connect() first.");
    return nc;
  }
  function isConnected() {
    return Boolean(nc) && !nc.isClosed();
  }
  function publishBytes(subject, payload, opts) {
    const conn = requireConnection();
    (async () => {
      const nats = await importNats();
      conn.publish(subject, payload, { headers: toNatsHeaders(nats, _optionalChain([opts, 'optionalAccess', _4 => _4.headers])) });
    })().catch((e) => emitStatus({ status: "error", data: e }));
  }
  function publishString(subject, payload, opts) {
    ;
    (async () => {
      const nats = await importNats();
      const sc = nats.StringCodec();
      publishBytes(subject, sc.encode(payload), opts);
    })().catch((e) => emitStatus({ status: "error", data: e }));
  }
  function publishJson(subject, payload, opts) {
    ;
    (async () => {
      const nats = await importNats();
      const jc = nats.JSONCodec();
      publishBytes(subject, jc.encode(payload), opts);
    })().catch((e) => emitStatus({ status: "error", data: e }));
  }
  async function requestBytes(subject, payload, opts) {
    const conn = requireConnection();
    const nats = await importNats();
    const msg = await conn.request(subject, payload, {
      timeout: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _5 => _5.timeoutMs]), () => ( 2e3)),
      headers: toNatsHeaders(nats, _optionalChain([opts, 'optionalAccess', _6 => _6.headers]))
    });
    return msg;
  }
  async function requestString(subject, payload, opts) {
    const nats = await importNats();
    const sc = nats.StringCodec();
    const msg = await requestBytes(subject, sc.encode(payload), opts);
    return sc.decode(msg.data);
  }
  async function requestJson(subject, payload, opts) {
    const nats = await importNats();
    const reqCodec = nats.JSONCodec();
    const resCodec = nats.JSONCodec();
    const msg = await requestBytes(subject, reqCodec.encode(payload), opts);
    return resCodec.decode(msg.data);
  }
  function subscribeBytes(subject, onMessage, opts) {
    const conn = requireConnection();
    const sub = conn.subscribe(subject, { queue: _optionalChain([opts, 'optionalAccess', _7 => _7.queue]) });
    if (typeof _optionalChain([opts, 'optionalAccess', _8 => _8.max]) === "number") sub.unsubscribe(opts.max);
    const abortController = new AbortController();
    const signal = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _9 => _9.signal]), () => ( abortController.signal));
    (async () => {
      try {
        for await (const msg of sub) {
          if (signal.aborted) break;
          await onMessage(msg);
        }
      } catch (e) {
        emitStatus({ status: "error", data: e });
      } finally {
        try {
          sub.unsubscribe();
        } catch (e4) {
        }
      }
    })().catch((e) => emitStatus({ status: "error", data: e }));
    return {
      subscription: sub,
      unsubscribe() {
        try {
          abortController.abort();
        } catch (e5) {
        }
        try {
          sub.unsubscribe();
        } catch (e6) {
        }
      }
    };
  }
  function subscribeString(subject, onMessage, opts) {
    return subscribeBytes(
      subject,
      async (msg) => {
        const nats = await importNats();
        const sc = nats.StringCodec();
        await onMessage(sc.decode(msg.data), msg);
      },
      opts
    );
  }
  function subscribeJson(subject, onMessage, opts) {
    return subscribeBytes(
      subject,
      async (msg) => {
        const nats = await importNats();
        const jc = nats.JSONCodec();
        await onMessage(jc.decode(msg.data), msg);
      },
      opts
    );
  }
  async function subscribeJetStreamOrdered(onMessage, opts) {
    const conn = requireConnection();
    if (_optionalChain([opts, 'access', _10 => _10.signal, 'optionalAccess', _11 => _11.aborted])) {
      return { unsubscribe() {
      } };
    }
    const nats = await importNats();
    if (_optionalChain([opts, 'access', _12 => _12.signal, 'optionalAccess', _13 => _13.aborted])) {
      return { unsubscribe() {
      } };
    }
    const inactiveThresholdNs = (_nullishCoalesce(opts.inactiveThresholdMs, () => ( 5 * 6e4))) * 1e6;
    const js = conn.jetstream();
    const consumer = await js.consumers.get(opts.streamName, {
      filterSubjects: opts.filterSubject,
      deliver_policy: nats.DeliverPolicy.StartSequence,
      opt_start_seq: _nullishCoalesce(opts.optStartSeq, () => ( 0)),
      inactive_threshold: inactiveThresholdNs
    });
    const iterRef = { current: null };
    let closed = false;
    const onAbort = () => {
      void teardown();
    };
    _optionalChain([opts, 'access', _14 => _14.signal, 'optionalAccess', _15 => _15.addEventListener, 'call', _16 => _16("abort", onAbort, { once: true })]);
    async function teardown() {
      if (closed) return;
      closed = true;
      _optionalChain([opts, 'access', _17 => _17.signal, 'optionalAccess', _18 => _18.removeEventListener, 'call', _19 => _19("abort", onAbort)]);
      const iter = iterRef.current;
      iterRef.current = null;
      if (iter) {
        try {
          await iter.close();
        } catch (e7) {
        }
      }
    }
    if (_optionalChain([opts, 'access', _20 => _20.signal, 'optionalAccess', _21 => _21.aborted])) {
      void teardown();
      return { unsubscribe() {
      } };
    }
    ;
    (async () => {
      try {
        const iter = await consumer.consume();
        if (closed) {
          try {
            await iter.close();
          } catch (e8) {
          }
          return;
        }
        iterRef.current = iter;
        for await (const msg of iter) {
          if (closed) break;
          try {
            await onMessage(msg);
          } catch (e) {
            emitStatus({ status: "error", data: e });
          }
        }
      } catch (e) {
        if (!closed) emitStatus({ status: "error", data: e });
      }
    })().catch((e) => emitStatus({ status: "error", data: e }));
    return {
      unsubscribe() {
        void teardown();
      }
    };
  }
  function onStatus(listener) {
    statusListeners.add(listener);
    return () => statusListeners.delete(listener);
  }
  return {
    connect,
    close,
    isConnected,
    publishBytes,
    publishString,
    publishJson,
    requestBytes,
    requestString,
    requestJson,
    subscribeBytes,
    subscribeString,
    subscribeJson,
    subscribeJetStreamOrdered,
    onStatus
  };
}

// src/nats/shared-connection.ts
var NATS_DEFAULTS = {
  SHARED_CLOSE_DELAY_MS: 3e3,
  CONNECT_TIMEOUT_MS: 1e4,
  PING_INTERVAL_MS: 3e4,
  MAX_PING_OUT: 3,
  RETRY_INITIAL_DELAY_MS: 1e3,
  RETRY_MAX_DELAY_MS: 3e4,
  RETRY_MULTIPLIER: 2
};
var shared = null;
function getSharedConnection() {
  return shared;
}
function acquireClient(url, opts) {
  if (_optionalChain([shared, 'optionalAccess', _22 => _22.wsUrl]) !== url) {
    if (shared) {
      if (shared.closeTimer) clearTimeout(shared.closeTimer);
      const old = shared;
      shared = null;
      void old.client.close().catch(() => {
      });
    }
    const {
      name = "openframe-frontend",
      user = "machine",
      pass = "",
      connectTimeoutMs = NATS_DEFAULTS.CONNECT_TIMEOUT_MS,
      pingIntervalMs = NATS_DEFAULTS.PING_INTERVAL_MS,
      maxPingOut = NATS_DEFAULTS.MAX_PING_OUT
    } = _nullishCoalesce(opts, () => ( {}));
    const client = createNatsClient({
      servers: url,
      name,
      user,
      pass,
      connectTimeoutMs,
      reconnect: false,
      pingIntervalMs,
      maxPingOut
    });
    shared = {
      wsUrl: url,
      client,
      connectPromise: null,
      refCount: 0,
      closeTimer: null,
      retryTimer: null,
      retryOwner: null
    };
  }
  shared.refCount += 1;
  if (shared.closeTimer) {
    clearTimeout(shared.closeTimer);
    shared.closeTimer = null;
  }
  return shared;
}
function releaseClient(url, opts) {
  if (!shared || shared.wsUrl !== url) return;
  shared.refCount = Math.max(0, shared.refCount - 1);
  if (shared.refCount > 0) return;
  const delay = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _23 => _23.delayMs]), () => ( NATS_DEFAULTS.SHARED_CLOSE_DELAY_MS));
  shared.closeTimer = setTimeout(() => {
    const s = shared;
    shared = null;
    if (s) {
      if (s.retryTimer) {
        clearTimeout(s.retryTimer);
        s.retryTimer = null;
      }
      void s.client.close().catch(() => {
      });
    }
  }, delay);
}
function getSharedConnectionFor(url) {
  if (!url) return null;
  return shared && shared.wsUrl === url ? shared : null;
}
var defaultShouldRetryOn = (status) => status === "closed" || status === "disconnected";
function startConnectionLifecycle(options) {
  const { conn, wsUrl } = options;
  const ownerToken = {};
  if (!conn.retryOwner) conn.retryOwner = ownerToken;
  let closed = false;
  let retryAttempt = 0;
  function emitSynthetic(status) {
    if (closed) return;
    _optionalChain([options, 'access', _24 => _24.onStatusChange, 'optionalCall', _25 => _25(status, { status })]);
    if (status === "connected") {
      retryAttempt = 0;
    }
  }
  function scheduleRetry() {
    if (closed) return;
    if (getSharedConnectionFor(wsUrl) !== conn) return;
    if (!conn.retryOwner) conn.retryOwner = ownerToken;
    if (conn.retryOwner !== ownerToken) return;
    if (conn.retryTimer) {
      clearTimeout(conn.retryTimer);
      conn.retryTimer = null;
    }
    const cfg = _nullishCoalesce(options.backoff, () => ( {}));
    const fastRetries = _nullishCoalesce(cfg.fastRetries, () => ( 0));
    const fastDelay = _nullishCoalesce(cfg.fastRetryDelayMs, () => ( NATS_DEFAULTS.RETRY_INITIAL_DELAY_MS));
    const baseDelay = _nullishCoalesce(cfg.initialDelayMs, () => ( NATS_DEFAULTS.RETRY_INITIAL_DELAY_MS));
    const maxDelay = _nullishCoalesce(cfg.maxDelayMs, () => ( NATS_DEFAULTS.RETRY_MAX_DELAY_MS));
    const multiplier = _nullishCoalesce(cfg.multiplier, () => ( NATS_DEFAULTS.RETRY_MULTIPLIER));
    const delay = retryAttempt < fastRetries ? fastDelay : Math.min(baseDelay * multiplier ** (retryAttempt - fastRetries), maxDelay);
    const jitteredDelay = delay * (0.5 + Math.random() * 0.5);
    retryAttempt++;
    conn.retryTimer = setTimeout(async () => {
      conn.retryTimer = null;
      if (closed) return;
      if (getSharedConnectionFor(wsUrl) !== conn) return;
      try {
        await _optionalChain([options, 'access', _26 => _26.onBeforeReconnect, 'optionalCall', _27 => _27()]);
      } catch (e9) {
      }
      if (closed) return;
      if (getSharedConnectionFor(wsUrl) !== conn) return;
      const freshUrl = options.getFreshUrl();
      if (freshUrl !== wsUrl) return;
      try {
        conn.connectPromise = null;
        conn.connectPromise = conn.client.connect();
        await conn.connectPromise;
        if (!closed && getSharedConnectionFor(wsUrl) === conn) {
          retryAttempt = 0;
        }
      } catch (e10) {
        conn.connectPromise = null;
        if (!closed && getSharedConnectionFor(wsUrl) === conn) {
          scheduleRetry();
        }
      }
    }, jitteredDelay);
  }
  const shouldRetryOn = _nullishCoalesce(options.shouldRetryOn, () => ( defaultShouldRetryOn));
  const unsubStatus = conn.client.onStatus((evt) => {
    if (closed) return;
    _optionalChain([options, 'access', _28 => _28.onStatusChange, 'optionalCall', _29 => _29(evt.status, evt)]);
    if (evt.status === "connected") {
      retryAttempt = 0;
    }
    if (shouldRetryOn(evt.status)) {
      scheduleRetry();
    }
  });
  if (conn.client.isConnected()) {
    emitSynthetic("connected");
  }
  void (async () => {
    try {
      conn.connectPromise || (conn.connectPromise = conn.client.connect());
      await conn.connectPromise;
    } catch (e11) {
      conn.connectPromise = null;
      if (closed) return;
      emitSynthetic("disconnected");
      scheduleRetry();
    }
  })();
  return {
    stop() {
      closed = true;
      unsubStatus();
      if (conn.retryTimer) {
        clearTimeout(conn.retryTimer);
        conn.retryTimer = null;
      }
      if (conn.retryOwner === ownerToken) {
        conn.retryOwner = null;
      }
    }
  };
}

// src/nats/nats-provider.tsx
var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react);
var _jsxruntime = require('react/jsx-runtime');
var NatsContext = React.createContext(null);
function NatsProvider({
  children,
  getWsUrl,
  onBeforeReconnect,
  clientConfig,
  reconnectionBackoff,
  urlRevision
}) {
  const [client, setClient] = React.useState(null);
  const [status, setStatus] = React.useState("closed");
  const [reconnectionCount, setReconnectionCount] = React.useState(0);
  const getWsUrlRef = React.useRef(getWsUrl);
  React.useEffect(() => {
    getWsUrlRef.current = getWsUrl;
  }, [getWsUrl]);
  const onBeforeReconnectRef = React.useRef(onBeforeReconnect);
  React.useEffect(() => {
    onBeforeReconnectRef.current = onBeforeReconnect;
  }, [onBeforeReconnect]);
  const reconnectionBackoffRef = React.useRef(reconnectionBackoff);
  React.useEffect(() => {
    reconnectionBackoffRef.current = reconnectionBackoff;
  }, [reconnectionBackoff]);
  const clientConfigRef = React.useRef(clientConfig);
  React.useEffect(() => {
    clientConfigRef.current = clientConfig;
  }, [clientConfig]);
  const heldUrlRef = React.useRef(null);
  const hadConnectionBeforeRef = React.useRef(false);
  React.useEffect(() => {
    const wsUrl = getWsUrlRef.current();
    if (!wsUrl) {
      if (heldUrlRef.current) {
        releaseClient(heldUrlRef.current);
        heldUrlRef.current = null;
        setClient(null);
        setStatus("closed");
      }
      return;
    }
    if (heldUrlRef.current && heldUrlRef.current !== wsUrl) {
      releaseClient(heldUrlRef.current);
      heldUrlRef.current = null;
    }
    const conn = acquireClient(wsUrl, clientConfigRef.current);
    heldUrlRef.current = wsUrl;
    setClient(conn.client);
    setStatus(conn.client.isConnected() ? "connected" : "connecting");
    const lifecycle = startConnectionLifecycle({
      conn,
      wsUrl,
      onBeforeReconnect: () => _optionalChain([onBeforeReconnectRef, 'access', _30 => _30.current, 'optionalCall', _31 => _31()]),
      backoff: reconnectionBackoffRef.current,
      getFreshUrl: () => getWsUrlRef.current(),
      onStatusChange: (newStatus) => {
        setStatus(newStatus);
        if (newStatus === "connected") {
          if (hadConnectionBeforeRef.current) {
            setReconnectionCount((c) => c + 1);
          }
          hadConnectionBeforeRef.current = true;
        }
      }
    });
    return () => {
      lifecycle.stop();
      if (heldUrlRef.current) {
        releaseClient(heldUrlRef.current);
        heldUrlRef.current = null;
      }
      setClient(null);
      setStatus("closed");
    };
  }, [urlRevision]);
  const value = React.useMemo(
    () => ({
      client,
      status,
      isReady: status === "connected" && client !== null,
      reconnectionCount
    }),
    [client, status, reconnectionCount]
  );
  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NatsContext.Provider, { value, children });
}
function useNats() {
  const ctx = React.useContext(NatsContext);
  if (!ctx) throw new Error("useNats must be used inside <NatsProvider>");
  return ctx;
}
function useOptionalNats() {
  return React.useContext(NatsContext);
}

// src/nats/use-nats-subscription.ts

function useNatsSubscription(subject, onMessage, options) {
  const nats = useOptionalNats();
  const handlerRef = React2.useRef(onMessage);
  React2.useEffect(() => {
    handlerRef.current = onMessage;
  }, [onMessage]);
  const [isSubscribed, setIsSubscribed] = React2.useState(false);
  const enabled = _optionalChain([options, 'optionalAccess', _32 => _32.enabled]) !== false;
  const queue = _optionalChain([options, 'optionalAccess', _33 => _33.queue]);
  const max = _optionalChain([options, 'optionalAccess', _34 => _34.max]);
  const reconnectionCount = _nullishCoalesce(_optionalChain([nats, 'optionalAccess', _35 => _35.reconnectionCount]), () => ( 0));
  const isReady = !!_optionalChain([nats, 'optionalAccess', _36 => _36.isReady]);
  const client = _nullishCoalesce(_optionalChain([nats, 'optionalAccess', _37 => _37.client]), () => ( null));
  React2.useEffect(() => {
    if (!client || !isReady || !subject || !enabled) {
      setIsSubscribed(false);
      return;
    }
    const sub = client.subscribeBytes(
      subject,
      (msg) => handlerRef.current(msg),
      { queue, max }
    );
    setIsSubscribed(true);
    return () => {
      setIsSubscribed(false);
      try {
        sub.unsubscribe();
      } catch (e12) {
      }
    };
  }, [client, isReady, subject, enabled, queue, max, reconnectionCount]);
  return { isSubscribed, isReady };
}
function useNatsJsonSubscription(subject, onPayload, options) {
  const handlerRef = React2.useRef(onPayload);
  React2.useEffect(() => {
    handlerRef.current = onPayload;
  }, [onPayload]);
  const decoderRef = React2.useRef(null);
  if (!decoderRef.current && typeof TextDecoder !== "undefined") {
    decoderRef.current = new TextDecoder();
  }
  const wrapped = React2.useCallback(async (msg) => {
    const decoder = decoderRef.current;
    if (!decoder) return;
    try {
      const parsed = JSON.parse(decoder.decode(msg.data));
      await handlerRef.current(parsed, msg);
    } catch (e13) {
    }
  }, []);
  return useNatsSubscription(subject, wrapped, options);
}














exports.createNatsClient = createNatsClient; exports.NATS_DEFAULTS = NATS_DEFAULTS; exports.getSharedConnection = getSharedConnection; exports.acquireClient = acquireClient; exports.releaseClient = releaseClient; exports.getSharedConnectionFor = getSharedConnectionFor; exports.startConnectionLifecycle = startConnectionLifecycle; exports.NatsProvider = NatsProvider; exports.useNats = useNats; exports.useOptionalNats = useOptionalNats; exports.useNatsSubscription = useNatsSubscription; exports.useNatsJsonSubscription = useNatsJsonSubscription;
//# sourceMappingURL=chunk-OZ3GH6OQ.cjs.map