@builder.io/sdk-vue 5.2.15 → 5.3.0

package/lib/node/should-force-browser-runtime-in-node-r2oi-Y6E.js

@@ -0,0 +1,725 @@
+import { createRequire } from "node:module";
+const TARGET = "vue", createBoundedCache = (e) => {
+  const t = /* @__PURE__ */ new Map();
+  return {
+    get: (r) => t.get(r),
+    set: (r, n) => {
+      !t.has(r) && t.size >= e && t.delete(t.keys().next().value), t.set(r, n);
+    }
+  };
+}, MSG_PREFIX = "[Builder.io]: ", logger = {
+  log: (...e) => console.log(MSG_PREFIX, ...e),
+  error: (...e) => console.error(MSG_PREFIX, ...e),
+  warn: (...e) => console.warn(MSG_PREFIX, ...e),
+  debug: (...e) => console.debug(MSG_PREFIX, ...e)
+};
+function isBrowser() {
+  return typeof window < "u" && typeof document < "u";
+}
+const convertSearchParamsToQueryObject = (e) => {
+  const t = {};
+  return e.forEach((r, n) => {
+    t[n] = r;
+  }), t;
+}, normalizeSearchParams = (e) => e instanceof URLSearchParams ? convertSearchParamsToQueryObject(e) : e, getSearchString = (e) => typeof e == "string" ? e : e instanceof URLSearchParams ? e.toString() : new URLSearchParams(e).toString();
+function isIframe() {
+  return isBrowser() && window.self !== window.top;
+}
+function isEditing(e) {
+  return isIframe() && // accessing window.location.search is safe here because `isIframe()` is only `true` if we're in a browser.
+  getSearchString(e || window.location.search).indexOf("builder.frameEditing=") !== -1;
+}
+const getLocation = () => {
+  if (isBrowser()) {
+    const e = new URL(location.href);
+    return e.pathname === "" && (e.pathname = "/"), e;
+  } else
+    return console.warn("Cannot get location for tracking in non-browser environment"), null;
+}, getUserAgent = () => typeof navigator == "object" && navigator.userAgent || "", getUserAttributes = () => {
+  const e = getUserAgent(), t = {
+    Android() {
+      return e.match(/Android/i);
+    },
+    BlackBerry() {
+      return e.match(/BlackBerry/i);
+    },
+    iOS() {
+      return e.match(/iPhone|iPod/i);
+    },
+    Opera() {
+      return e.match(/Opera Mini/i);
+    },
+    Windows() {
+      return e.match(/IEMobile/i) || e.match(/WPDesktop/i);
+    },
+    any() {
+      return t.Android() || t.BlackBerry() || t.iOS() || t.Opera() || t.Windows() || TARGET === "reactNative";
+    }
+  }, r = e.match(/Tablet|iPad/i), n = getLocation();
+  return {
+    urlPath: n == null ? void 0 : n.pathname,
+    host: (n == null ? void 0 : n.host) || (n == null ? void 0 : n.hostname),
+    device: r ? "tablet" : t.any() ? "mobile" : "desktop"
+  };
+}, SDK_VERSION = "5.3.0", getSdkHeaders = () => ({
+  "X-Builder-SDK": TARGET,
+  "X-Builder-SDK-GEN": "2",
+  "X-Builder-SDK-Version": SDK_VERSION
+}), checkIsDefined = (e) => e != null, getTopLevelDomain = (e) => {
+  if (e === "localhost" || e === "127.0.0.1")
+    return e;
+  const t = e.split(".");
+  return t.length > 2 ? t.slice(1).join(".") : e;
+}, getCookieSync = ({
+  name: e,
+  canTrack: t
+}) => {
+  var r;
+  try {
+    return t ? (r = document.cookie.split("; ").find((n) => n.startsWith(`${e}=`))) == null ? void 0 : r.split("=")[1] : void 0;
+  } catch (n) {
+    logger.warn("[COOKIE] GET error: ", (n == null ? void 0 : n.message) || n);
+    return;
+  }
+}, getCookie = async (e) => getCookieSync(e), stringifyCookie = (e) => e.map(([t, r]) => r ? `${t}=${r}` : t).filter(checkIsDefined).join("; "), SECURE_CONFIG = [["secure", ""], ["SameSite", "None"]], createCookieString = ({
+  name: e,
+  value: t,
+  expires: r
+}) => {
+  const o = (isBrowser() ? location.protocol === "https:" : !0) ? SECURE_CONFIG : [[]], s = r ? [["expires", r.toUTCString()]] : [[]], a = [[e, t], ...s, ["path", "/"], ["domain", getTopLevelDomain(window.location.hostname)], ...o];
+  return stringifyCookie(a);
+}, setCookie = async ({
+  name: e,
+  value: t,
+  expires: r,
+  canTrack: n
+}) => {
+  try {
+    if (!n)
+      return;
+    const o = createCookieString({
+      name: e,
+      value: t,
+      expires: r
+    });
+    document.cookie = o;
+  } catch (o) {
+    logger.warn("[COOKIE] SET error: ", (o == null ? void 0 : o.message) || o);
+  }
+};
+function uuidv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(e) {
+    const t = Math.random() * 16 | 0;
+    return (e == "x" ? t : t & 3 | 8).toString(16);
+  });
+}
+function uuid() {
+  return uuidv4().replace(/-/g, "");
+}
+const SESSION_LOCAL_STORAGE_KEY = "builderSessionId", getSessionId = async ({
+  canTrack: e
+}) => {
+  if (!e)
+    return;
+  const t = await getCookie({
+    name: SESSION_LOCAL_STORAGE_KEY,
+    canTrack: e
+  });
+  if (checkIsDefined(t))
+    return t;
+  {
+    const r = createSessionId();
+    return setSessionId({
+      id: r,
+      canTrack: e
+    }), r;
+  }
+}, createSessionId = () => uuid(), setSessionId = ({
+  id: e,
+  canTrack: t
+}) => setCookie({
+  name: SESSION_LOCAL_STORAGE_KEY,
+  value: e,
+  canTrack: t
+}), getLocalStorage = () => isBrowser() && typeof localStorage < "u" ? localStorage : void 0, getLocalStorageItem = ({
+  key: e,
+  canTrack: t
+}) => {
+  var r;
+  try {
+    return t ? (r = getLocalStorage()) == null ? void 0 : r.getItem(e) : void 0;
+  } catch (n) {
+    console.debug("[LocalStorage] GET error: ", n);
+    return;
+  }
+}, setLocalStorageItem = ({
+  key: e,
+  canTrack: t,
+  value: r
+}) => {
+  var n;
+  try {
+    t && ((n = getLocalStorage()) == null || n.setItem(e, r));
+  } catch (o) {
+    console.debug("[LocalStorage] SET error: ", o);
+  }
+}, VISITOR_LOCAL_STORAGE_KEY = "builderVisitorId", getVisitorId = ({
+  canTrack: e
+}) => {
+  if (!e)
+    return;
+  const t = getLocalStorageItem({
+    key: VISITOR_LOCAL_STORAGE_KEY,
+    canTrack: e
+  });
+  if (checkIsDefined(t))
+    return t;
+  {
+    const r = createVisitorId();
+    return setVisitorId({
+      id: r,
+      canTrack: e
+    }), r;
+  }
+}, createVisitorId = () => uuid(), setVisitorId = ({
+  id: e,
+  canTrack: t
+}) => setLocalStorageItem({
+  key: VISITOR_LOCAL_STORAGE_KEY,
+  value: e,
+  canTrack: t
+});
+function logFetch(e) {
+  var t;
+  typeof process < "u" && ((t = process.env) != null && t.DEBUG) && String(process.env.DEBUG) == "true" && logger.log(e);
+}
+const getTrackingEventData = async ({
+  canTrack: e
+}) => {
+  if (!e)
+    return {
+      visitorId: void 0,
+      sessionId: void 0
+    };
+  const t = await getSessionId({
+    canTrack: e
+  }), r = getVisitorId({
+    canTrack: e
+  });
+  return {
+    sessionId: t,
+    visitorId: r
+  };
+}, createEvent = async ({
+  type: e,
+  canTrack: t,
+  apiKey: r,
+  metadata: n,
+  ...o
+}) => ({
+  type: e,
+  data: {
+    ...o,
+    metadata: {
+      url: location.href,
+      ...n
+    },
+    ...await getTrackingEventData({
+      canTrack: t
+    }),
+    userAttributes: getUserAttributes(),
+    ownerId: r
+  }
+});
+async function _track({
+  apiHost: e,
+  ...t
+}) {
+  if (!t.apiKey) {
+    logger.error("Missing API key for track call. Please provide your API key.");
+    return;
+  }
+  if (!t.canTrack || isEditing() || !(isBrowser() || TARGET === "reactNative"))
+    return;
+  const n = `${e || "https://cdn.builder.io"}/api/v1/track`;
+  return logFetch(n), fetch(n, {
+    method: "POST",
+    body: JSON.stringify({
+      events: [await createEvent(t)]
+    }),
+    headers: {
+      "content-type": "application/json",
+      ...getSdkHeaders()
+    },
+    mode: "cors"
+  }).catch((o) => {
+    console.error("Failed to track: ", o);
+  });
+}
+const track = (e) => _track({
+  ...e,
+  canTrack: !0
+}), getFunctionArguments = ({
+  builder: e,
+  context: t,
+  event: r,
+  state: n
+}) => Object.entries({
+  state: n,
+  Builder: e,
+  // legacy
+  builder: e,
+  context: t,
+  event: r
+}), getBuilderGlobals = (e) => ({
+  isEditing: isEditing(),
+  isBrowser: isBrowser(),
+  isServer: !isBrowser(),
+  getUserAttributes: () => getUserAttributes(),
+  trackConversion: (t, r) => {
+    !(e != null && e.apiKey) || (e == null ? void 0 : e.canTrack) === !1 || _track({
+      type: "conversion",
+      apiKey: e.apiKey,
+      canTrack: e.canTrack ?? !0,
+      contentId: e.contentId,
+      variationId: e.variationId !== e.contentId ? e.variationId : void 0,
+      metadata: {
+        ...r || {},
+        ...t !== void 0 ? {
+          amount: t
+        } : {}
+      }
+    });
+  }
+}), parseCode = (e, {
+  isExpression: t = !0
+}) => /* we disable this for cases where we definitely don't want a return */ t && !(e.includes(";") || e.includes(" return ") || e.trim().startsWith("return ")) ? `return (${e});` : e;
+function flattenState({
+  rootState: e,
+  localState: t,
+  rootSetState: r
+}) {
+  return new Proxy(e, {
+    get: (n, o) => {
+      if (t && o in t)
+        return t[o];
+      const s = n[o];
+      return typeof s == "object" && s !== null ? flattenState({
+        rootState: s,
+        localState: void 0,
+        rootSetState: r ? (a) => {
+          n[o] = a, r(n);
+        } : void 0
+      }) : s;
+    },
+    set: (n, o, s) => {
+      if (t && o in t)
+        throw new Error("Writing to local state is not allowed as it is read-only.");
+      return n[o] = s, r == null || r(n), !0;
+    }
+  });
+}
+const SDK_NAME_FOR_TARGET = (() => {
+  switch (TARGET) {
+    case "rsc":
+      return "react-nextjs";
+    case "reactNative":
+      return "react-native";
+    default:
+      return TARGET;
+  }
+})(), SDK_NAME = `@builder.io/sdk-${SDK_NAME_FOR_TARGET}`, fastClone = (e) => JSON.parse(JSON.stringify(e)), parsePath = (e) => e.toString().match(/[^.[\]]+/g), isArrayIndex = (e) => Math.abs(Number(e)) >> 0 === +e, hasUnsafeSegment = (e) => e.some((t, r) => t === "__proto__" || r < e.length - 1 && (t === "constructor" || t === "prototype")), getOwn = (e, t) => Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0, set = (e, t, r) => {
+  if (Object(e) !== e)
+    return e;
+  const n = Array.isArray(t) ? t : parsePath(t);
+  return !n || hasUnsafeSegment(n) || (n.slice(0, -1).reduce((o, s, a) => {
+    const c = getOwn(o, s);
+    return Object(c) === c ? c : o[s] = isArrayIndex(n[a + 1]) ? [] : {};
+  }, e)[n[n.length - 1]] = r), e;
+}, setCopyOnWrite = (e, t, r, n) => {
+  if (Object(e) !== e)
+    return e;
+  const o = parsePath(t);
+  if (!o || hasUnsafeSegment(o))
+    return e;
+  n.add(e);
+  let s = e;
+  for (let a = 0; a < o.length - 1; a++) {
+    const c = o[a];
+    let i = getOwn(s, c);
+    Object(i) !== i ? (i = isArrayIndex(o[a + 1]) ? [] : {}, n.add(i), s[c] = i) : typeof i == "object" && !n.has(i) && (i = Array.isArray(i) ? i.slice() : {
+      ...i
+    }, n.add(i), s[c] = i), s = i;
+  }
+  return s[o[o.length - 1]] = r, e;
+}, unset = (e, t) => {
+  if (Object(e) !== e || !t.length || hasUnsafeSegment(t))
+    return e;
+  const r = t.slice(0, -1).reduce((n, o) => Object(n) === n ? getOwn(n, o) : void 0, e);
+  return Object(r) === r && delete r[t[t.length - 1]], e;
+}, IDENTIFIER = /^[A-Za-z_$][\w$]*/, NUMBER = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/, getStringLiteralLength = (e) => {
+  const t = e[0];
+  if (t !== '"' && t !== "'")
+    return 0;
+  for (let r = 1; r < e.length; r++) {
+    const n = e[r];
+    if (n === t)
+      return r + 1;
+    if (n === "\\" || n === `
+` || n === "\r")
+      return 0;
+  }
+  return 0;
+}, OPERATORS = ["===", "!==", "==", "!=", "<=", ">=", "&&", "||", "??", "<", ">", "!", "+", "-", "*", "/", "%", "?", ":"], LITERAL_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null", "undefined"]), BLOCKED_PROPERTIES = /* @__PURE__ */ new Set(["constructor", "__proto__", "prototype", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"]), MAX_EXPRESSION_LENGTH = 500, getSafeStateExpression = (e) => {
+  var s;
+  if (e.length > MAX_EXPRESSION_LENGTH)
+    return null;
+  let t = e.trim();
+  if (!t)
+    return null;
+  let r = 0, n = !1, o = !1;
+  for (; t; ) {
+    const a = /^\s+/.exec(t);
+    if (a) {
+      t = t.slice(a[0].length);
+      continue;
+    }
+    const c = IDENTIFIER.exec(t);
+    if (c) {
+      if (n)
+        return null;
+      const E = c[0];
+      if (t = t.slice(E.length), LITERAL_KEYWORDS.has(E)) {
+        n = !0;
+        continue;
+      }
+      if (E !== "state")
+        return null;
+      let S = !1, l = /^\s*\.\s*([A-Za-z_$][\w$]*)/.exec(t);
+      for (; l; ) {
+        if (BLOCKED_PROPERTIES.has(l[1]))
+          return null;
+        S = !0, t = t.slice(l[0].length), l = /^\s*\.\s*([A-Za-z_$][\w$]*)/.exec(t);
+      }
+      if (!S)
+        return null;
+      o = !0, n = !0;
+      continue;
+    }
+    const i = ((s = NUMBER.exec(t)) == null ? void 0 : s[0].length) || getStringLiteralLength(t);
+    if (i) {
+      if (n)
+        return null;
+      t = t.slice(i), n = !0;
+      continue;
+    }
+    if (t[0] === "(") {
+      if (n)
+        return null;
+      r++, t = t.slice(1);
+      continue;
+    }
+    if (t[0] === ")") {
+      if (r === 0)
+        return null;
+      r--, t = t.slice(1), n = !0;
+      continue;
+    }
+    const u = OPERATORS.find((E) => t.startsWith(E));
+    if (!u || u === "?" && t[1] === "." || (u === "+" || u === "-") && t[1] === u)
+      return null;
+    t = t.slice(u.length), n = !1;
+  }
+  return r !== 0 || !o || !n ? null : e.trim();
+}, RETURN_EXPRESSION = /^\s*return\s*\(([\s\S]*)\);\s*$/, VIRTUAL_INDEX_EXPRESSION = /^\s*var\s+_virtual_index\s*=\s*([\s\S]*?);?\s*return\s+_virtual_index\s*;?\s*$/, getSafeStateExpressionFromCode = (e) => {
+  const t = RETURN_EXPRESSION.exec(e) || VIRTUAL_INDEX_EXPRESSION.exec(e);
+  return t ? getSafeStateExpression(t[1]) : null;
+}, isPrimitiveValue = (e) => e === null || typeof e != "object" && typeof e != "function", MAX_CACHED_EXPRESSIONS = 5e3, COMPILED_EXPRESSIONS = createBoundedCache(MAX_CACHED_EXPRESSIONS), getSafeStateExpressionFn = (e) => {
+  let t = COMPILED_EXPRESSIONS.get(e);
+  if (t === void 0) {
+    const r = getSafeStateExpressionFromCode(e);
+    if (t = null, r)
+      try {
+        t = new Function("state", `return (${r});`);
+      } catch {
+        t = null;
+      }
+    COMPILED_EXPRESSIONS.set(e, t);
+  }
+  return t;
+}, UNSAFE_STATE_READ = Symbol("unsafe state read"), isPlainContainer = (e) => {
+  const t = Object.getPrototypeOf(e);
+  return t === Object.prototype || t === Array.prototype || t === null;
+}, READ_ONLY_TRAPS = {
+  set: () => !1,
+  deleteProperty: () => !1
+}, findDescriptor = (e, t) => {
+  for (let r = e; r; r = Object.getPrototypeOf(r)) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+  }
+}, getReadOnlyStateView = (e, t, r) => {
+  const n = (c) => !r(c) && isPlainContainer(c);
+  if (!n(e) || t && r(t))
+    throw UNSAFE_STATE_READ;
+  const o = /* @__PURE__ */ new WeakMap(), s = (c) => {
+    if (c === null || typeof c != "object") {
+      if (typeof c == "function")
+        throw UNSAFE_STATE_READ;
+      return c;
+    }
+    if (!n(c))
+      throw UNSAFE_STATE_READ;
+    let i = o.get(c);
+    return i || (i = new Proxy(Array.isArray(c) ? [] : {}, {
+      get: (u, E) => a(c, E),
+      ...READ_ONLY_TRAPS
+    }), o.set(c, i)), i;
+  }, a = (c, i) => {
+    const u = findDescriptor(c, i);
+    if (u && (u.get || u.set))
+      throw UNSAFE_STATE_READ;
+    return s(u == null ? void 0 : u.value);
+  };
+  return new Proxy({}, {
+    get: (c, i) => t && Object.prototype.hasOwnProperty.call(t, i) ? a(t, i) : a(e, i),
+    ...READ_ONLY_TRAPS
+  });
+}, NOT_EVALUATED = Symbol("not evaluated"), evaluateSafeStateExpression = (e, t, r, n) => {
+  const o = getSafeStateExpressionFn(e);
+  if (!o)
+    return NOT_EVALUATED;
+  let s;
+  try {
+    s = o(getReadOnlyStateView(t, r, n));
+  } catch {
+    return NOT_EVALUATED;
+  }
+  return isPrimitiveValue(s) ? s : NOT_EVALUATED;
+}, noop = () => {
+};
+let safeDynamicRequire = noop;
+try {
+  safeDynamicRequire = createRequire(import.meta.url);
+} catch (error) {
+  try {
+    safeDynamicRequire = eval("require");
+  } catch (e) {
+  }
+}
+const getSyncValName = (e) => `bldr_${e}_sync`, BUILDER_SET_STATE_NAME = "BUILDER_SET_STATE", BUILDER_DELETE_STATE_NAME = "BUILDER_DELETE_STATE", INJECTED_IVM_GLOBAL = "BUILDER_IVM", REF_TO_PROXY_FN = `
+var refToProxy = (obj, path) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+  return new Proxy({}, {
+    get(target, key) {
+        if (key === 'copySync') {
+          return () => obj.copySync();
+        }
+        const val = obj.getSync(key);
+        if (typeof val?.getSync === 'function') {
+            return refToProxy(val, path && path.concat(key));
+        }
+        return val;
+    },
+    set(target, key, value) {
+        // Functions cannot cross the isolate boundary, and server renders never call them.
+        if (typeof value === 'function') {
+          return true;
+        }
+        const v = typeof value === 'object' ? new ${INJECTED_IVM_GLOBAL}.Reference(value) : value;
+        obj.setSync(key, v);
+        if (path) ${BUILDER_SET_STATE_NAME}(path.concat(key), value);
+        return true;
+    },
+    deleteProperty(target, key) {
+        obj.deleteSync(key);
+        if (path) ${BUILDER_DELETE_STATE_NAME}(path.concat(key));
+        return true;
+    }
+  })
+}
+`, processCode = ({
+  code: e,
+  args: t
+}) => {
+  const r = t.map(([n]) => `var ${n} = refToProxy(${getSyncValName(n)}${n === "state" ? ", []" : ""}); `).join("");
+  return `(function () {
+${REF_TO_PROXY_FN}
+${r}
+function theFunction() {
+  ${e}
+}
+
+const output = theFunction()
+
+if (typeof output === 'object' && output !== null) {
+  return JSON.stringify(output.copySync ? output.copySync() : output);
+} else {
+  return output;
+}
+})()`;
+};
+let IVM_INSTANCE = null, IVM_OPTIONS = {
+  memoryLimit: 128
+};
+const MAX_EVALUATIONS_PER_ISOLATE = 1e3;
+let POOLED = null, DISPOSE_TIMER = null, IS_EXIT_HANDLER_REGISTERED = !1;
+const disposePooledIsolate = () => {
+  if (DISPOSE_TIMER && (clearTimeout(DISPOSE_TIMER), DISPOSE_TIMER = null), POOLED && !POOLED.isolate.isDisposed)
+    try {
+      POOLED.isolate.dispose();
+    } catch {
+    }
+  POOLED = null;
+}, getPooledIsolate = (e) => {
+  var t;
+  return (!POOLED || POOLED.isolate.isDisposed || POOLED.evaluations >= MAX_EVALUATIONS_PER_ISOLATE) && (disposePooledIsolate(), POOLED = {
+    isolate: new e.Isolate(IVM_OPTIONS),
+    evaluations: 0,
+    scripts: /* @__PURE__ */ new Map()
+  }), DISPOSE_TIMER || (DISPOSE_TIMER = setTimeout(disposePooledIsolate, 0), (t = DISPOSE_TIMER.unref) == null || t.call(DISPOSE_TIMER)), !IS_EXIT_HANDLER_REGISTERED && typeof process < "u" && typeof process.once == "function" && (IS_EXIT_HANDLER_REGISTERED = !0, process.once("exit", disposePooledIsolate)), POOLED.evaluations++, POOLED;
+}, setIvm = (e, t) => {
+  IVM_INSTANCE || (IVM_INSTANCE = e, t && (IVM_OPTIONS = t));
+}, SHOULD_MENTION_INITIALIZE_SCRIPT = SDK_NAME === "@builder.io/sdk-react-nextjs" || SDK_NAME === "@builder.io/sdk-react" || SDK_NAME === "@builder.io/sdk-qwik" || SDK_NAME === "@builder.io/sdk-vue", getIvm = () => {
+  try {
+    if (IVM_INSTANCE)
+      return IVM_INSTANCE;
+    const t = safeDynamicRequire("isolated-vm");
+    if (t)
+      return t;
+  } catch (t) {
+    logger.error("isolated-vm import error.", t);
+  }
+  const e = `${MSG_PREFIX}could not import \`isolated-vm\` module for safe script execution on a Node server.
+    
+    SOLUTION: In a server-only execution path within your application, do one of the following:
+  
+    ${SHOULD_MENTION_INITIALIZE_SCRIPT ? `- import and call \`initializeNodeRuntime()\` from "${SDK_NAME}/node/init".` : ""}
+    - add the following import: \`await import('isolated-vm')\`.
+
+    For more information, visit https://builder.io/c/docs/integration-tips#enabling-data-bindings-in-node-environments`;
+  throw new Error(e);
+};
+let IS_PROXY;
+const getIsProxy = () => {
+  var e, t;
+  if (IS_PROXY === void 0)
+    try {
+      IS_PROXY = ((t = (e = safeDynamicRequire("node:util")) == null ? void 0 : e.types) == null ? void 0 : t.isProxy) ?? null;
+    } catch {
+      IS_PROXY = null;
+    }
+  return IS_PROXY;
+}, runInNode = ({
+  code: e,
+  builder: t,
+  context: r,
+  event: n,
+  localState: o,
+  rootSetState: s,
+  rootState: a
+}) => {
+  const c = getIsProxy();
+  if (c) {
+    const l = evaluateSafeStateExpression(e, a, o, c);
+    if (l !== NOT_EVALUATED)
+      return l;
+  }
+  const i = getIvm(), u = getPooledIsolate(i), E = u.isolate.createContextSync(), S = [];
+  try {
+    const l = E.global;
+    l.setSync("global", l.derefInto()), l.setSync("log", function(...d) {
+      console.log(...d);
+    }), l.setSync(INJECTED_IVM_GLOBAL, i);
+    const g = fastClone({
+      ...a,
+      ...o
+    }), p = getFunctionArguments({
+      builder: t,
+      context: r,
+      event: n,
+      state: g
+    });
+    l.setSync(BUILDER_SET_STATE_NAME, function(d, f) {
+      set(a, d, f), s == null || s(a);
+    }), l.setSync(BUILDER_DELETE_STATE_NAME, function(d) {
+      unset(a, d), s == null || s(a);
+    }), p.forEach(([d, f]) => {
+      const _ = typeof f == "object" ? new i.Reference(
+        // workaround: methods with default values for arguments is not being cloned over
+        d === "builder" ? {
+          ...f,
+          getUserAttributes: () => f.getUserAttributes()
+        } : f
+      ) : null;
+      _ && S.push(_), l.setSync(getSyncValName(d), _);
+    });
+    let I = u.scripts.get(e);
+    I || (I = u.isolate.compileScriptSync(processCode({
+      code: e,
+      args: p
+    })), u.scripts.set(e, I));
+    const O = I.runSync(E);
+    try {
+      return JSON.parse(O);
+    } catch {
+      return O;
+    }
+  } finally {
+    S.forEach((l) => {
+      try {
+        l.release();
+      } catch {
+      }
+    });
+    try {
+      E.release();
+    } catch {
+    }
+  }
+};
+function isNodeRuntime() {
+  var e;
+  return typeof process < "u" && checkIsDefined((e = process == null ? void 0 : process.versions) == null ? void 0 : e.node);
+}
+let hasLoggedWarning = !1;
+const shouldForceBrowserRuntimeInNode = ({
+  shouldLogWarning: e
+}) => {
+  var o;
+  if (!isNodeRuntime())
+    return !1;
+  const t = process.arch === "arm64", r = process.version.startsWith("v20"), n = (o = process.env.NODE_OPTIONS) == null ? void 0 : o.includes("--no-node-snapshot");
+  return t && r && !n ? (e && !hasLoggedWarning && (hasLoggedWarning = !0, logger.log("Skipping usage of `isolated-vm` to avoid crashes in Node v20 on an arm64 machine.\n    If you would like to use the `isolated-vm` package on this machine, please provide the `NODE_OPTIONS=--no-node-snapshot` config to your Node process.\n    See https://github.com/BuilderIO/builder/blob/main/packages/sdks/README.md#node-v20--m1-macs-apple-silicon-support for more information.\n    ")), !0) : !1;
+};
+export {
+  SDK_VERSION as S,
+  TARGET as T,
+  _track as _,
+  getBuilderGlobals as a,
+  getSearchString as b,
+  createBoundedCache as c,
+  isEditing as d,
+  setCopyOnWrite as e,
+  flattenState as f,
+  getFunctionArguments as g,
+  getCookieSync as h,
+  isBrowser as i,
+  checkIsDefined as j,
+  getCookie as k,
+  logger as l,
+  setCookie as m,
+  normalizeSearchParams as n,
+  getSdkHeaders as o,
+  parseCode as p,
+  set as q,
+  runInNode as r,
+  shouldForceBrowserRuntimeInNode as s,
+  logFetch as t,
+  fastClone as u,
+  track as v,
+  setIvm as w
+};