@builder.io/sdk-svelte 0.6.4 → 0.7.1-0

package/lib/browser/blocks/custom-code/custom-code.svelte

@@ -3,52 +3,50 @@
 <script>import { onMount } from "svelte";
 export let replaceNodes = undefined;
 export let code;
-function findAndRunScripts() {
+let elementRef;
+let scriptsInserted = [];
+let scriptsRun = [];
+onMount(() => {
     // TODO: Move this function to standalone one in '@builder.io/utils'
-    if (elem && elem.getElementsByTagName && typeof window !== "undefined") {
-        const scripts = elem.getElementsByTagName("script");
-        for (let i = 0; i < scripts.length; i++) {
-            const script = scripts[i];
-            if (script.src) {
-                if (scriptsInserted.includes(script.src)) {
-                    continue;
-                }
-                scriptsInserted.push(script.src);
-                const newScript = document.createElement("script");
-                newScript.async = true;
-                newScript.src = script.src;
-                document.head.appendChild(newScript);
+    if (!elementRef?.getElementsByTagName || typeof window === "undefined") {
+        return;
+    }
+    const scripts = elementRef.getElementsByTagName("script");
+    for (let i = 0; i < scripts.length; i++) {
+        const script = scripts[i];
+        if (script.src) {
+            if (scriptsInserted.includes(script.src)) {
+                continue;
+            }
+            scriptsInserted.push(script.src);
+            const newScript = document.createElement("script");
+            newScript.async = true;
+            newScript.src = script.src;
+            document.head.appendChild(newScript);
+        }
+        else if (!script.type ||
+            [
+                "text/javascript",
+                "application/javascript",
+                "application/ecmascript",
+            ].includes(script.type)) {
+            if (scriptsRun.includes(script.innerText)) {
+                continue;
+            }
+            try {
+                scriptsRun.push(script.innerText);
+                new Function(script.innerText)();
             }
-            else if (!script.type ||
-                [
-                    "text/javascript",
-                    "application/javascript",
-                    "application/ecmascript",
-                ].includes(script.type)) {
-                if (scriptsRun.includes(script.innerText)) {
-                    continue;
-                }
-                try {
-                    scriptsRun.push(script.innerText);
-                    new Function(script.innerText)();
-                }
-                catch (error) {
-                    console.warn("`CustomCode`: Error running script:", error);
-                }
+            catch (error) {
+                console.warn("`CustomCode`: Error running script:", error);
             }
         }
     }
-}
-let elem;
-let scriptsInserted = [];
-let scriptsRun = [];
-onMount(() => {
-    findAndRunScripts();
 });
 </script>
 
 <div
-  bind:this={elem}
+  bind:this={elementRef}
   class={"builder-custom-code" + (replaceNodes ? " replace-nodes" : "")}
 >
   {@html code}

package/lib/browser/components/content/components/enable-editor.svelte

@@ -9,24 +9,24 @@ import { createRegisterComponentMessage } from "../../../functions/register-comp
 import { _track } from "../../../functions/track/index.js";
 import builderContext from "../../../context/builder.context.js";
 import { registerInsertMenu, setupBrowserForEditing, } from "../../../scripts/init-editing.js";
-import { checkIsDefined } from "../../../helpers/nullable.js";
 import { getInteractionPropertiesForEvent } from "../../../functions/track/interaction.js";
-import { logger } from "../../../helpers/logger.js";
 import { fetchOneEntry } from "../../../functions/get-content/index.js";
 import { isPreviewing } from "../../../functions/is-previewing.js";
 import "../../../helpers/preview-lru-cache/set.js";
 import { fastClone } from "../../../functions/fast-clone.js";
-export let canTrack = undefined;
+import { logger } from "../../../helpers/logger.js";
+import { getDefaultCanTrack } from "../../../helpers/canTrack.js";
 export let builderContextSignal;
 export let model = undefined;
 export let context = undefined;
+export let canTrack = undefined;
 export let apiKey;
-export let showContent;
-export let classNameProp;
-export let content = undefined;
 export let locale = undefined;
 export let includeRefs = undefined;
 export let enrich = undefined;
+export let content = undefined;
+export let showContent;
+export let classNameProp;
 function mergeNewContent(newContent) {
     const newContentValue = {
         ...$builderContextSignal.content,
@@ -99,7 +99,7 @@ function onClick(event) {
         const contentId = $builderContextSignal.content?.id;
         _track({
             type: "click",
-            canTrack: canTrackToUse,
+            canTrack: getDefaultCanTrack(canTrack),
             contentId,
             apiKey: apiKey,
             variationId: variationId !== contentId ? variationId : undefined,
@@ -159,90 +159,99 @@ function emitStateUpdate() {
         }));
     }
 }
+function elementRef_onIniteditingbldr(event) {
+    forceReRenderCount = forceReRenderCount + 1;
+    window.addEventListener("message", processMessage);
+    registerInsertMenu();
+    setupBrowserForEditing({
+        ...(locale
+            ? {
+                locale: locale,
+            }
+            : {}),
+        ...(includeRefs
+            ? {
+                includeRefs: includeRefs,
+            }
+            : {}),
+        ...(enrich
+            ? {
+                enrich: enrich,
+            }
+            : {}),
+    });
+    Object.values($builderContextSignal.componentInfos).forEach((registeredComponent) => {
+        const message = createRegisterComponentMessage(registeredComponent);
+        window.parent?.postMessage(message, "*");
+    });
+    window.addEventListener("builder:component:stateChangeListenerActivated", emitStateUpdate);
+}
+function elementRef_onInitpreviewingbldr(event) {
+    const searchParams = new URL(location.href).searchParams;
+    const searchParamPreviewModel = searchParams.get("builder.preview");
+    const searchParamPreviewId = searchParams.get(`builder.preview.${searchParamPreviewModel}`);
+    const previewApiKey = searchParams.get("apiKey") || searchParams.get("builder.space");
+    /**
+     * Make sure that:
+     * - the preview model name is the same as the one we're rendering, since there can be multiple models rendered
+     *  at the same time, e.g. header/page/footer.
+     * - the API key is the same, since we don't want to preview content from other organizations.
+     * - if there is content, that the preview ID is the same as that of the one we receive.
+     *
+     * TO-DO: should we only update the state when there is a change?
+     **/
+    if (searchParamPreviewModel === model &&
+        previewApiKey === apiKey &&
+        (!content || searchParamPreviewId === content.id)) {
+        fetchOneEntry({
+            model: model,
+            apiKey: apiKey,
+            apiVersion: $builderContextSignal.apiVersion,
+        }).then((content) => {
+            if (content) {
+                mergeNewContent(content);
+            }
+        });
+    }
+}
 let elementRef;
-let canTrackToUse = checkIsDefined(canTrack) ? canTrack : true;
 let forceReRenderCount = 0;
 let lastUpdated = 0;
 let shouldSendResetCookie = false;
 let httpReqsData = {};
 let clicked = false;
 onMount(() => {
-    if (!apiKey) {
-        logger.error("No API key provided to `RenderContent` component. This can cause issues. Please provide an API key using the `apiKey` prop.");
-    }
     if (isBrowser()) {
-        if (isEditing()) {
-            forceReRenderCount = forceReRenderCount + 1;
-            window.addEventListener("message", processMessage);
-            registerInsertMenu();
-            setupBrowserForEditing({
-                ...(locale
-                    ? {
-                        locale: locale,
-                    }
-                    : {}),
-                ...(includeRefs
-                    ? {
-                        includeRefs: includeRefs,
-                    }
-                    : {}),
-                ...(enrich
-                    ? {
-                        enrich: enrich,
-                    }
-                    : {}),
-            });
-            Object.values($builderContextSignal.componentInfos).forEach((registeredComponent) => {
-                const message = createRegisterComponentMessage(registeredComponent);
-                window.parent?.postMessage(message, "*");
-            });
-            window.addEventListener("builder:component:stateChangeListenerActivated", emitStateUpdate);
+        if (isEditing() && elementRef) {
+            elementRef.dispatchEvent(new CustomEvent("initeditingbldr"));
         }
-        if ($builderContextSignal.content) {
+        const shouldTrackImpression = $builderContextSignal.content && getDefaultCanTrack(canTrack);
+        if (shouldTrackImpression) {
             const variationId = $builderContextSignal.content?.testVariationId;
             const contentId = $builderContextSignal.content?.id;
+            const apiKeyProp = apiKey;
             _track({
                 type: "impression",
-                canTrack: canTrackToUse,
+                canTrack: true,
                 contentId,
-                apiKey: apiKey,
+                apiKey: apiKeyProp,
                 variationId: variationId !== contentId ? variationId : undefined,
             });
         }
         // override normal content in preview mode
-        if (isPreviewing()) {
-            const searchParams = new URL(location.href).searchParams;
-            const searchParamPreviewModel = searchParams.get("builder.preview");
-            const searchParamPreviewId = searchParams.get(`builder.preview.${searchParamPreviewModel}`);
-            const previewApiKey = searchParams.get("apiKey") || searchParams.get("builder.space");
-            /**
-             * Make sure that:
-             * - the preview model name is the same as the one we're rendering, since there can be multiple models rendered
-             *  at the same time, e.g. header/page/footer.
-             * - the API key is the same, since we don't want to preview content from other organizations.
-             * - if there is content, that the preview ID is the same as that of the one we receive.
-             *
-             * TO-DO: should we only update the state when there is a change?
-             **/
-            if (searchParamPreviewModel === model &&
-                previewApiKey === apiKey &&
-                (!content || searchParamPreviewId === content.id)) {
-                fetchOneEntry({
-                    model: model,
-                    apiKey: apiKey,
-                    apiVersion: $builderContextSignal.apiVersion,
-                }).then((content) => {
-                    if (content) {
-                        mergeNewContent(content);
-                    }
-                });
-            }
+        if (isPreviewing() && elementRef) {
+            elementRef.dispatchEvent(new CustomEvent("initpreviewingbldr"));
         }
-        evaluateJsCode();
-        runHttpRequests();
-        emitStateUpdate();
     }
 });
+onMount(() => {
+    if (!apiKey) {
+        logger.error("No API key provided to `RenderContent` component. This can cause issues. Please provide an API key using the `apiKey` prop.");
+    }
+    evaluateJsCode();
+    runHttpRequests();
+    emitStateUpdate();
+});
 function onUpdateFn_0(..._args) {
     if (content) {
         mergeNewContent(content);
@@ -277,6 +286,7 @@ onDestroy(() => {
 
 {#if $builderContextSignal.content}
   <div
+    {...{}}
     key={forceReRenderCount}
     bind:this={elementRef}
     on:click={(event) => {
@@ -292,6 +302,12 @@ onDestroy(() => {
           "aria-hidden": true,
         }}
     class={classNameProp}
+    on:initeditingbldr={(event) => {
+      elementRef_onIniteditingbldr(event);
+    }}
+    on:initpreviewingbldr={(event) => {
+      elementRef_onInitpreviewingbldr(event);
+    }}
   >
     <slot />
   </div>

package/lib/browser/components/content/components/enable-editor.svelte.d.ts

@@ -9,17 +9,17 @@ import type { ContentProps } from "../content.types.js";
 import type { Writable } from "svelte/store";
 declare const __propDef: {
     props: {
-        canTrack?: BuilderEditorProps["canTrack"];
         builderContextSignal: BuilderEditorProps["builderContextSignal"];
         model?: BuilderEditorProps["model"];
         context?: BuilderEditorProps["context"];
+        canTrack?: BuilderEditorProps["canTrack"];
         apiKey: BuilderEditorProps["apiKey"];
-        showContent: BuilderEditorProps["showContent"];
-        classNameProp: BuilderEditorProps["classNameProp"];
-        content?: BuilderEditorProps["content"];
         locale?: BuilderEditorProps["locale"];
         includeRefs?: BuilderEditorProps["includeRefs"];
         enrich?: BuilderEditorProps["enrich"];
+        content?: BuilderEditorProps["content"];
+        showContent: BuilderEditorProps["showContent"];
+        classNameProp: BuilderEditorProps["classNameProp"];
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/lib/browser/constants/sdk-version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.6.4";
+export declare const SDK_VERSION = "0.7.1-0";

package/lib/browser/constants/sdk-version.js

@@ -1 +1 @@
-export const SDK_VERSION = "0.6.4";
+export const SDK_VERSION = "0.7.1-0";

package/lib/browser/functions/evaluate/choose-eval.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutorArgs } from './helpers.js';
+/**
+ * Even though we have separate runtimes for browser/node/edge, sometimes frameworks will
+ * end up sending the server runtime code to the browser (most notably in dev mode).
+ */
+export declare const chooseBrowserOrServerEval: (args: ExecutorArgs) => any;

package/lib/browser/functions/evaluate/choose-eval.js

@@ -0,0 +1,19 @@
+import { runInBrowser } from './browser-runtime/browser.js';
+import { isBrowser } from '../is-browser.js';
+/**
+ * THIS IS A MAGICAL IMPORT. It is aliased by the build process of every SDK configuration, so that
+ * it points to the correct runtime for that configuration, which are expected to live exactly at:
+ *  - ./browser-runtime/index.js
+ *  - ./node-runtime/index.js
+ *  - ./edge-runtime/index.js
+ *
+ * We have code in `/output-generation` that does this aliasing, and is re-used by each SDK.
+ * Also, each individual `tsconfig.json` aliases this import to the browser runtime so that the
+ * types can be resolved correctly.
+ */
+import { evaluator } from '../../../browser/functions/evaluate/browser-runtime/index.js';
+/**
+ * Even though we have separate runtimes for browser/node/edge, sometimes frameworks will
+ * end up sending the server runtime code to the browser (most notably in dev mode).
+ */
+export const chooseBrowserOrServerEval = (args) => isBrowser() ? runInBrowser(args) : evaluator(args);

package/lib/browser/functions/evaluate/evaluate.d.ts

@@ -1,6 +1,2 @@
-import type { ExecutorArgs } from './helpers.js';
-export type EvaluatorArgs = Omit<ExecutorArgs, 'builder' | 'event'> & {
-    event?: Event;
-    isExpression?: boolean;
-};
+import type { EvaluatorArgs } from './helpers.js';
 export declare function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression }: EvaluatorArgs): any;

package/lib/browser/functions/evaluate/evaluate.js

@@ -1,39 +1,16 @@
 import { logger } from '../../helpers/logger.js';
-import { isBrowser } from '../is-browser.js';
-import { isEditing } from '../is-editing.js';
-import { getUserAttributes } from '../track/helpers.js';
-/**
- * THIS IS A MAGICAL IMPORT. It is aliased by the build process of every SDK configuration, so that
- * it points to the correct runtime for that configuration, which are expected to live exactly at:
- *  - ./browser-runtime/index.js
- *  - ./node-runtime/index.js
- *  - ./edge-runtime/index.js
- *
- * We have code in `/output-generation` that does this aliasing, and is re-used by each SDK.
- * Also, each individual `tsconfig.json` aliases this import to the browser runtime so that the
- * types can be resolved correctly.
- */
-import { evaluator } from '../../../browser/functions/evaluate/browser-runtime/index.js';
+import { getBuilderGlobals, parseCode } from './helpers.js';
+import { chooseBrowserOrServerEval } from './choose-eval.js';
 export function evaluate({ code, context, localState, rootState, rootSetState, event, isExpression = true }) {
     if (code === '') {
         logger.warn('Skipping evaluation of empty code block.');
         return;
     }
-    const builder = {
-        isEditing: isEditing(),
-        isBrowser: isBrowser(),
-        isServer: !isBrowser(),
-        getUserAttributes: () => getUserAttributes()
-    };
-    // Be able to handle simple expressions like "state.foo" or "1 + 1"
-    // as well as full blocks like "var foo = "bar"; return foo"
-    const useReturn = 
-    // we disable this for cases where we definitely don't want a return
-    isExpression && !(code.includes(';') || code.includes(' return ') || code.trim().startsWith('return '));
-    const useCode = useReturn ? `return (${code});` : code;
     const args = {
-        code: useCode,
-        builder,
+        code: parseCode(code, {
+            isExpression
+        }),
+        builder: getBuilderGlobals(),
         context,
         event,
         rootSetState,
@@ -41,7 +18,7 @@ export function evaluate({ code, context, localState, rootState, rootSetState, e
         localState
     };
     try {
-        return evaluator(args);
+        return chooseBrowserOrServerEval(args);
     }
     catch (e) {
         logger.error('Failed code evaluation: ' + e.message, {

package/lib/browser/functions/evaluate/helpers.d.ts

@@ -1,5 +1,9 @@
 import type { BuilderContextInterface, BuilderRenderState } from '../../context/types.js';
-import type { getUserAttributes } from '../track/helpers.js';
+import { getUserAttributes } from '../track/helpers.js';
+export type EvaluatorArgs = Omit<ExecutorArgs, 'builder' | 'event'> & {
+    event?: Event;
+    isExpression?: boolean;
+};
 export type BuilderGlobals = {
     isEditing: boolean | undefined;
     isBrowser: boolean | undefined;
@@ -16,3 +20,5 @@ export type FunctionArguments = ReturnType<typeof getFunctionArguments>;
 export declare const getFunctionArguments: ({ builder, context, event, state }: Pick<ExecutorArgs, "context" | "builder" | "event"> & {
     state: BuilderRenderState;
 }) => [string, Event | BuilderRenderState | import("../../context/types.js").BuilderRenderContext | BuilderGlobals | undefined][];
+export declare const getBuilderGlobals: () => BuilderGlobals;
+export declare const parseCode: (code: string, { isExpression }: Pick<EvaluatorArgs, 'isExpression'>) => string;

package/lib/browser/functions/evaluate/helpers.js

@@ -1,3 +1,6 @@
+import { isBrowser } from '../is-browser.js';
+import { isEditing } from '../is-editing.js';
+import { getUserAttributes } from '../track/helpers.js';
 export const getFunctionArguments = ({ builder, context, event, state }) => {
     return Object.entries({
         state,
@@ -8,3 +11,18 @@ export const getFunctionArguments = ({ builder, context, event, state }) => {
         event
     });
 };
+export const getBuilderGlobals = () => ({
+    isEditing: isEditing(),
+    isBrowser: isBrowser(),
+    isServer: !isBrowser(),
+    getUserAttributes: () => getUserAttributes()
+});
+export const parseCode = (code, { isExpression = true }) => {
+    // Be able to handle simple expressions like "state.foo" or "1 + 1"
+    // as well as full blocks like "var foo = "bar"; return foo"
+    const useReturn = 
+    // we disable this for cases where we definitely don't want a return
+    isExpression && !(code.includes(';') || code.includes(' return ') || code.trim().startsWith('return '));
+    const useCode = useReturn ? `return (${code});` : code;
+    return useCode;
+};

package/lib/browser/functions/evaluate/node-runtime/index.d.ts

@@ -1 +1 @@
-export { evaluator } from '../browser-runtime/index.js';
+export { runInNode as evaluator } from './node-runtime.js';

package/lib/browser/functions/evaluate/node-runtime/index.js

@@ -1 +1 @@
-export { evaluator } from '../browser-runtime/index.js';
+export { runInNode as evaluator } from './node-runtime.js';

package/lib/browser/functions/evaluate/node-runtime/node-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ExecutorArgs } from '../helpers.js';
+export declare const runInNode: ({ code, builder, context, event, localState, rootSetState, rootState }: ExecutorArgs) => any;

package/lib/browser/functions/evaluate/node-runtime/node-runtime.js

@@ -0,0 +1,120 @@
+import { getFunctionArguments } from '../helpers.js';
+import { safeDynamicRequire } from './safeDynamicRequire.js';
+import { fastClone } from '../../fast-clone.js';
+import { set } from '../../set.js';
+const ivm = safeDynamicRequire('isolated-vm');
+const getSyncValName = (key) => `bldr_${key}_sync`;
+const BUILDER_SET_STATE_NAME = 'BUILDER_SET_STATE';
+const INJECTED_IVM_GLOBAL = 'BUILDER_IVM';
+// Convert all argument references to proxies, and pass `copySync` method to target object, to return a copy of the original JS object
+// https://github.com/laverdet/isolated-vm#referencecopysync
+const REF_TO_PROXY_FN = `
+var refToProxy = (obj) => {
+  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);
+        }
+        return val;
+    },
+    set(target, key, value) {
+        const v = typeof value === 'object' ? new ${INJECTED_IVM_GLOBAL}.Reference(value) : value;
+        obj.setSync(key, v);
+        ${BUILDER_SET_STATE_NAME}(key, value)
+    },
+    deleteProperty(target, key) {
+        obj.deleteSync(key);
+    }
+  })
+}
+`;
+const processCode = ({ code, args }) => {
+    const fnArgs = args.map(([name]) => `var ${name} = refToProxy(${getSyncValName(name)}); `).join('');
+    // the output is stringified and parsed back to the parent isolate if needed (when it's an `object`)
+    return `
+${REF_TO_PROXY_FN}
+${fnArgs}
+function theFunction() {
+  ${code}
+}
+
+let output = theFunction()
+
+if (typeof output === 'object' && output !== null) {
+  output = JSON.stringify(output.copySync ? output.copySync() : output);
+}
+
+output;
+`;
+};
+const getIsolateContext = () => {
+    // if (Builder.serverContext) {
+    //   return Builder.serverContext;
+    // }
+    // Builder.setServerContext(isolate.createContextSync());
+    const isolate = new ivm.Isolate({
+        memoryLimit: 128
+    });
+    return isolate.createContextSync();
+};
+export const runInNode = ({ code, builder, context, event, localState, rootSetState, rootState }) => {
+    const state = fastClone({
+        ...rootState,
+        ...localState
+    });
+    const args = getFunctionArguments({
+        builder,
+        context,
+        event,
+        state
+    });
+    const isolateContext = getIsolateContext();
+    const jail = isolateContext.global;
+    // This makes the global object available in the context as `global`. We use `derefInto()` here
+    // because otherwise `global` would actually be a Reference{} object in the new isolate.
+    jail.setSync('global', jail.derefInto());
+    // We will create a basic `log` function for the new isolate to use.
+    jail.setSync('log', function (...logArgs) {
+        console.log(...logArgs);
+    });
+    /**
+     * Propagate state changes back to the reactive root state.
+     */
+    jail.setSync(BUILDER_SET_STATE_NAME, function (key, value) {
+        // mutate the `rootState` object itself. Important for cases where we do not have `rootSetState`
+        // like Qwik.
+        set(rootState, key, value);
+        // call the `rootSetState` function if it exists
+        rootSetState?.(rootState);
+    });
+    args.forEach(([key, arg]) => {
+        const val = typeof arg === 'object' ? new ivm.Reference(
+        // workaround: methods with default values for arguments is not being cloned over
+        key === 'builder' ? {
+            ...arg,
+            getUserAttributes: () => arg.getUserAttributes()
+        } : arg) : null;
+        jail.setSync(getSyncValName(key), val);
+    });
+    jail.setSync(INJECTED_IVM_GLOBAL, ivm);
+    const evalStr = processCode({
+        code,
+        args
+    });
+    const resultStr = isolateContext.evalSync(evalStr);
+    try {
+        // returning objects throw errors in isolated vm, so we stringify it and parse it back
+        const res = JSON.parse(resultStr);
+        return res;
+    }
+    catch (_error) {
+        return resultStr;
+    }
+};

package/lib/browser/functions/evaluate/node-runtime/safeDynamicRequire.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="react-native" />
+/**
+ * Allows us to require node-specific code safely within bundlers.
+ *
+ * https://github.com/laverdet/isolated-vm/issues/423
+ *
+ * NOTE: this code should only ever run in `node`, and never in an `edge` runtime.
+ * This is guaranteed by the fact that each SDK has separate bundles for each runtime.
+ * However, it might still end up running in the `browser` if the `node` bundle is loaded in the
+ * browser (which happens in many apps' dev mode, and certain other scenarios like Qwik's prod mode).
+ */
+export declare let safeDynamicRequire: typeof require;

package/lib/browser/functions/evaluate/node-runtime/safeDynamicRequire.js

@@ -0,0 +1,18 @@
+const noop = () => null;
+/**
+ * Allows us to require node-specific code safely within bundlers.
+ *
+ * https://github.com/laverdet/isolated-vm/issues/423
+ *
+ * NOTE: this code should only ever run in `node`, and never in an `edge` runtime.
+ * This is guaranteed by the fact that each SDK has separate bundles for each runtime.
+ * However, it might still end up running in the `browser` if the `node` bundle is loaded in the
+ * browser (which happens in many apps' dev mode, and certain other scenarios like Qwik's prod mode).
+ */
+export let safeDynamicRequire = noop;
+try {
+    safeDynamicRequire = eval('require');
+}
+catch (error) {
+    /* empty */
+}