@builder.io/sdk-svelte 0.5.9 → 0.6.0

package/README.md

@@ -21,7 +21,3 @@ Take a look at [our example repo](/examples/svelte/sveltekit) for how to use thi
 ## Fetch
 
 This Package uses fetch. See [these docs](https://github.com/BuilderIO/this-package-uses-fetch/blob/main/README.md) for more information.
-
-## Non-Node.js Runtimes (Edge, Serverless)
-
-If planning to deploy your app to a non-Node.js runtime (like Edge or Serverless functions), make sure to read the [Non-Node.js Runtimes](../../README.md#non-nodejs-runtimes-edge-serverless) section of the main README.

package/lib/browser/blocks/columns/columns.svelte

@@ -0,0 +1,156 @@
+<script context="module"></script>
+
+<script>import Blocks from "../../components/blocks/blocks.svelte";
+import { getSizesForBreakpoints } from "../../constants/device-sizes.js";
+import InlinedStyles from "../../components/inlined-styles.svelte";
+import { TARGET } from "../../constants/target.js";
+import "../../functions/deopt.js";
+export let js;
+export let space = undefined;
+export let columns = undefined;
+export let stackColumnsAt = undefined;
+export let reverseColumnsWhenStacked = undefined;
+export let builderContext;
+export let builderBlock;
+export let builderComponents;
+function mitosis_styling(node, vars) {
+    Object.entries(vars || {}).forEach(([p, v]) => {
+        if (p.startsWith("--")) {
+            node.style.setProperty(p, v);
+        }
+        else {
+            node.style[p] = v;
+        }
+    });
+}
+function getWidth(index) {
+    return cols[index]?.width || 100 / cols.length;
+}
+function getColumnCssWidth(index) {
+    const subtractWidth = (gutterSize * (cols.length - 1)) / cols.length;
+    return `calc(${getWidth(index)}% - ${subtractWidth}px)`;
+}
+function getTabletStyle({ stackedStyle, desktopStyle, }) {
+    return stackAt === "tablet" ? stackedStyle : desktopStyle;
+}
+function getMobileStyle({ stackedStyle, desktopStyle, }) {
+    return stackAt === "never" ? desktopStyle : stackedStyle;
+}
+function columnCssVars(index) {
+    const gutter = index === 0 ? 0 : gutterSize;
+    const width = getColumnCssWidth(index);
+    const gutterPixels = `${gutter}px`;
+    const mobileWidth = "100%";
+    const mobileMarginLeft = 0;
+    const marginLeftKey = "margin-left";
+    return {
+        width,
+        [marginLeftKey]: gutterPixels,
+        "--column-width-mobile": getMobileStyle({
+            stackedStyle: mobileWidth,
+            desktopStyle: width,
+        }),
+        "--column-margin-left-mobile": getMobileStyle({
+            stackedStyle: mobileMarginLeft,
+            desktopStyle: gutterPixels,
+        }),
+        "--column-width-tablet": getTabletStyle({
+            stackedStyle: mobileWidth,
+            desktopStyle: width,
+        }),
+        "--column-margin-left-tablet": getTabletStyle({
+            stackedStyle: mobileMarginLeft,
+            desktopStyle: gutterPixels,
+        }),
+    };
+}
+function getWidthForBreakpointSize(size) {
+    const breakpointSizes = getSizesForBreakpoints($builderContext.content?.meta?.breakpoints || {});
+    return breakpointSizes[size].max;
+}
+$: columnsCssVars = () => {
+    return {
+        "--flex-dir": flexDir,
+        "--flex-dir-tablet": getTabletStyle({
+            stackedStyle: flexDir,
+            desktopStyle: "row",
+        }),
+    };
+};
+$: columnsStyles = () => {
+    return `
+        @media (max-width: ${getWidthForBreakpointSize("medium")}px) {
+          .${builderBlock.id}-breakpoints {
+            flex-direction: var(--flex-dir-tablet);
+            align-items: stretch;
+          }
+
+          .${builderBlock.id}-breakpoints > .builder-column {
+            width: var(--column-width-tablet) !important;
+            margin-left: var(--column-margin-left-tablet) !important;
+          }
+        }
+
+        @media (max-width: ${getWidthForBreakpointSize("small")}px) {
+          .${builderBlock.id}-breakpoints {
+            flex-direction: var(--flex-dir);
+            align-items: stretch;
+          }
+
+          .${builderBlock.id}-breakpoints > .builder-column {
+            width: var(--column-width-mobile) !important;
+            margin-left: var(--column-margin-left-mobile) !important;
+          }
+        },
+      `;
+};
+let gutterSize = typeof space === "number" ? space || 0 : 20;
+let cols = columns || [];
+let stackAt = stackColumnsAt || "tablet";
+let flexDir = stackColumnsAt === "never"
+    ? "row"
+    : reverseColumnsWhenStacked
+        ? "column-reverse"
+        : "column";
+</script>
+
+<div
+  use:mitosis_styling={columnsCssVars()}
+  class={`builder-columns ${builderBlock.id}-breakpoints` + " div"}
+  {...{}}
+>
+  {#if TARGET !== "reactNative"}
+    <InlinedStyles styles={columnsStyles()} />
+  {/if}
+
+  {#each columns as column, index (index)}
+    <div
+      use:mitosis_styling={columnCssVars(index)}
+      class="builder-column div-2"
+      {...{}}
+    >
+      <Blocks
+        path={`component.options.columns.${index}.blocks`}
+        parent={builderBlock.id}
+        styleProp={{
+          flexGrow: "1",
+        }}
+        context={builderContext}
+        registeredComponents={builderComponents}
+        blocks={column.blocks}
+      />
+    </div>
+  {/each}
+</div>
+
+<style>
+  .div {
+    display: flex;
+    line-height: normal;
+  }
+  .div-2 {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+  }
+</style>

package/lib/browser/blocks/columns/columns.svelte.d.ts

@@ -0,0 +1,37 @@
+import { SvelteComponent } from "svelte";
+type Column = {
+    blocks: BuilderBlock[];
+    width?: number;
+};
+type StackColumnsAt = "tablet" | "mobile" | "never";
+export interface ColumnProps extends BuilderComponentsProp {
+    columns?: Column[];
+    builderBlock: BuilderBlock;
+    space?: number;
+    stackColumnsAt?: StackColumnsAt;
+    reverseColumnsWhenStacked?: boolean;
+}
+import type { BuilderBlock } from "../../types/builder-block.js";
+import type { BuilderComponentsProp, PropsWithBuilderData } from "../../types/builder-props.js";
+declare const __propDef: {
+    props: {
+        js: any;
+        space?: PropsWithBuilderData<ColumnProps>["space"];
+        columns?: PropsWithBuilderData<ColumnProps>["columns"];
+        stackColumnsAt?: PropsWithBuilderData<ColumnProps>["stackColumnsAt"];
+        reverseColumnsWhenStacked?: PropsWithBuilderData<ColumnProps>["reverseColumnsWhenStacked"];
+        builderContext: PropsWithBuilderData<ColumnProps>["builderContext"];
+        builderBlock: PropsWithBuilderData<ColumnProps>["builderBlock"];
+        builderComponents: PropsWithBuilderData<ColumnProps>["builderComponents"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ColumnsProps = typeof __propDef.props;
+export type ColumnsEvents = typeof __propDef.events;
+export type ColumnsSlots = typeof __propDef.slots;
+export default class Columns extends SvelteComponent<ColumnsProps, ColumnsEvents, ColumnsSlots> {
+}
+export {};

package/lib/browser/blocks/form/form.svelte.d.ts

@@ -0,0 +1,14 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FormProps = typeof __propDef.props;
+export type FormEvents = typeof __propDef.events;
+export type FormSlots = typeof __propDef.slots;
+export default class Form extends SvelteComponent<FormProps, FormEvents, FormSlots> {
+}
+export {};

package/lib/browser/blocks/submit-button/submit-button.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponent } from "svelte";
+/**
+ * This import is used by the Svelte SDK. Do not remove.
+ */ export interface ButtonProps {
+    attributes?: any;
+    text?: string;
+}
+declare const __propDef: {
+    props: {
+        attributes?: ButtonProps["attributes"];
+        text?: ButtonProps["text"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type SubmitButtonProps = typeof __propDef.props;
+export type SubmitButtonEvents = typeof __propDef.events;
+export type SubmitButtonSlots = typeof __propDef.slots;
+export default class SubmitButton extends SvelteComponent<SubmitButtonProps, SubmitButtonEvents, SubmitButtonSlots> {
+}
+export {};

package/lib/browser/blocks/text/text.svelte

@@ -0,0 +1,21 @@
+<script context="module"></script>
+
+<script>export let text = undefined;
+function mitosis_styling(node, vars) {
+    Object.entries(vars || {}).forEach(([p, v]) => {
+        if (p.startsWith("--")) {
+            node.style.setProperty(p, v);
+        }
+        else {
+            node.style[p] = v;
+        }
+    });
+}
+</script>
+
+<span
+  use:mitosis_styling={{
+    outline: "none",
+  }}
+  class="builder-text">{@html text?.toString() || ""}</span
+>

package/lib/browser/components/block/components/block-wrapper.svelte.d.ts

@@ -0,0 +1,33 @@
+import { SvelteComponent } from "svelte";
+/**
+ * This import is used by the Svelte SDK. Do not remove.
+ */ type BlockWrapperProps = {
+    Wrapper: string;
+    block: BuilderBlock;
+    context: Writable<BuilderContextInterface>;
+    hasChildren: boolean;
+};
+import type { PropsWithChildren } from "../../../types/typescript.js";
+import type { BuilderBlock } from "../../../types/builder-block.js";
+import type { BuilderContextInterface } from "../../../context/types.js";
+import type { Writable } from "svelte/store";
+declare const __propDef: {
+    props: {
+        Wrapper: PropsWithChildren<BlockWrapperProps>["Wrapper"];
+        block: PropsWithChildren<BlockWrapperProps>["block"];
+        context: PropsWithChildren<BlockWrapperProps>["context"];
+        hasChildren: PropsWithChildren<BlockWrapperProps>["hasChildren"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+type BlockWrapperProps_ = typeof __propDef.props;
+export { BlockWrapperProps_ as BlockWrapperProps };
+export type BlockWrapperEvents = typeof __propDef.events;
+export type BlockWrapperSlots = typeof __propDef.slots;
+export default class BlockWrapper extends SvelteComponent<BlockWrapperProps, BlockWrapperEvents, BlockWrapperSlots> {
+}

package/lib/browser/components/block/components/component-ref/component-ref.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+import type { ComponentProps } from "./component-ref.helpers.js";
+declare const __propDef: {
+    props: {
+        isInteractive: ComponentProps["isInteractive"];
+        componentRef: ComponentProps["componentRef"];
+        componentOptions: ComponentProps["componentOptions"];
+        builderBlock: ComponentProps["builderBlock"];
+        context: ComponentProps["context"];
+        includeBlockProps: ComponentProps["includeBlockProps"];
+        blockChildren: ComponentProps["blockChildren"];
+        registeredComponents: ComponentProps["registeredComponents"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ComponentRefProps = typeof __propDef.props;
+export type ComponentRefEvents = typeof __propDef.events;
+export type ComponentRefSlots = typeof __propDef.slots;
+export default class ComponentRef extends SvelteComponent<ComponentRefProps, ComponentRefEvents, ComponentRefSlots> {
+}
+export {};

package/lib/browser/components/block/components/repeated-block.svelte.d.ts

@@ -0,0 +1,25 @@
+import { SvelteComponent } from "svelte";
+type Props = {
+    block: BuilderBlock;
+    repeatContext: BuilderContextInterface;
+    registeredComponents: RegisteredComponents;
+};
+import type { BuilderContextInterface, RegisteredComponents } from "../../../context/types.js";
+import type { BuilderBlock } from "../../../types/builder-block.js";
+declare const __propDef: {
+    props: {
+        repeatContext: Props["repeatContext"];
+        block: Props["block"];
+        registeredComponents: Props["registeredComponents"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type RepeatedBlockProps = typeof __propDef.props;
+export type RepeatedBlockEvents = typeof __propDef.events;
+export type RepeatedBlockSlots = typeof __propDef.slots;
+export default class RepeatedBlock extends SvelteComponent<RepeatedBlockProps, RepeatedBlockEvents, RepeatedBlockSlots> {
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { SvelteComponent } from "svelte";
+type BuilderEditorProps = Omit<ContentProps, "customComponents" | "data" | "apiVersion" | "isSsrAbTest"> & {
+    builderContextSignal: Writable<BuilderContextInterface>;
+    setBuilderContextSignal?: (signal: any) => any;
+    children?: any;
+};
+import type { BuilderContextInterface } from "../../../context/types.js";
+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"];
+        apiKey: BuilderEditorProps["apiKey"];
+        showContent: BuilderEditorProps["showContent"];
+        classNameProp: BuilderEditorProps["classNameProp"];
+        content?: BuilderEditorProps["content"];
+        locale?: BuilderEditorProps["locale"];
+        includeRefs?: BuilderEditorProps["includeRefs"];
+        enrich?: BuilderEditorProps["enrich"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type EnableEditorProps = typeof __propDef.props;
+export type EnableEditorEvents = typeof __propDef.events;
+export type EnableEditorSlots = typeof __propDef.slots;
+export default class EnableEditor extends SvelteComponent<EnableEditorProps, EnableEditorEvents, EnableEditorSlots> {
+}
+export {};

package/lib/browser/components/content/components/styles.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+interface Props {
+    cssCode?: string;
+    customFonts?: CustomFont[];
+    contentId?: string;
+}
+import type { CustomFont } from "./styles.helpers.js";
+declare const __propDef: {
+    props: {
+        cssCode?: Props["cssCode"];
+        contentId?: Props["contentId"];
+        customFonts?: Props["customFonts"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type StylesProps = typeof __propDef.props;
+export type StylesEvents = typeof __propDef.events;
+export type StylesSlots = typeof __propDef.slots;
+export default class Styles extends SvelteComponent<StylesProps, StylesEvents, StylesSlots> {
+}
+export {};

package/lib/browser/components/content/content.svelte.d.ts

@@ -0,0 +1,30 @@
+import { SvelteComponent } from "svelte";
+import type { ContentProps } from "./content.types.js";
+declare const __propDef: {
+    props: {
+        content?: ContentProps["content"];
+        customComponents?: ContentProps["customComponents"];
+        data?: ContentProps["data"];
+        locale?: ContentProps["locale"];
+        context?: ContentProps["context"];
+        apiKey: ContentProps["apiKey"];
+        apiVersion?: ContentProps["apiVersion"];
+        model?: ContentProps["model"];
+        canTrack?: ContentProps["canTrack"];
+        includeRefs?: ContentProps["includeRefs"];
+        enrich?: ContentProps["enrich"];
+        classNameProp: ContentProps["classNameProp"];
+        showContent: ContentProps["showContent"];
+        isSsrAbTest: ContentProps["isSsrAbTest"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+type ContentProps_ = typeof __propDef.props;
+export { ContentProps_ as ContentProps };
+export type ContentEvents = typeof __propDef.events;
+export type ContentSlots = typeof __propDef.slots;
+export default class Content extends SvelteComponent<ContentProps, ContentEvents, ContentSlots> {
+}

package/lib/browser/components/content-variants/content-variants.svelte.d.ts

@@ -0,0 +1,34 @@
+import { SvelteComponent } from "svelte";
+type VariantsProviderProps = ContentVariantsPrps & {
+    /**
+     * For internal use only. Do not provide this prop.
+     */
+    __isNestedRender?: boolean;
+};
+import type { ContentVariantsPrps } from "./content-variants.types.js";
+declare const __propDef: {
+    props: {
+        canTrack?: VariantsProviderProps["canTrack"];
+        content?: VariantsProviderProps["content"];
+        __isNestedRender?: VariantsProviderProps["__isNestedRender"];
+        model?: VariantsProviderProps["model"];
+        data?: VariantsProviderProps["data"];
+        context?: VariantsProviderProps["context"];
+        apiKey: VariantsProviderProps["apiKey"];
+        apiVersion?: VariantsProviderProps["apiVersion"];
+        customComponents?: VariantsProviderProps["customComponents"];
+        locale?: VariantsProviderProps["locale"];
+        includeRefs?: VariantsProviderProps["includeRefs"];
+        enrich?: VariantsProviderProps["enrich"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ContentVariantsProps = typeof __propDef.props;
+export type ContentVariantsEvents = typeof __propDef.events;
+export type ContentVariantsSlots = typeof __propDef.slots;
+export default class ContentVariants extends SvelteComponent<ContentVariantsProps, ContentVariantsEvents, ContentVariantsSlots> {
+}
+export {};

package/lib/browser/components/inlined-script.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+interface Props {
+    scriptStr: string;
+    id?: string;
+}
+declare const __propDef: {
+    props: {
+        scriptStr: Props["scriptStr"];
+        id?: Props["id"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type InlinedScriptProps = typeof __propDef.props;
+export type InlinedScriptEvents = typeof __propDef.events;
+export type InlinedScriptSlots = typeof __propDef.slots;
+export default class InlinedScript extends SvelteComponent<InlinedScriptProps, InlinedScriptEvents, InlinedScriptSlots> {
+}
+export {};

package/lib/browser/components/inlined-styles.svelte.d.ts

@@ -0,0 +1,21 @@
+import { SvelteComponent } from "svelte";
+interface Props {
+    styles: string;
+    id?: string;
+}
+declare const __propDef: {
+    props: {
+        styles: Props["styles"];
+        id?: Props["id"];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type InlinedStylesProps = typeof __propDef.props;
+export type InlinedStylesEvents = typeof __propDef.events;
+export type InlinedStylesSlots = typeof __propDef.slots;
+export default class InlinedStyles extends SvelteComponent<InlinedStylesProps, InlinedStylesEvents, InlinedStylesSlots> {
+}
+export {};

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

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.6.0";

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

@@ -0,0 +1 @@
+export const SDK_VERSION = "0.6.0";

package/lib/browser/context/builder.context.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="svelte" />
+declare const _default: {
+    Builder: import("svelte/store").Writable<{
+        content: null;
+        context: {};
+        localState: undefined;
+        rootSetState(): void;
+        rootState: {};
+        apiKey: null;
+        apiVersion: undefined;
+        componentInfos: {};
+        inheritedStyles: {};
+    }>;
+    key: symbol;
+};
+export default _default;

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

@@ -0,0 +1,4 @@
+/**
+ * Workaround until https://github.com/BuilderIO/qwik/issues/5017 is fixed.
+ */
+export declare function deoptSignal<T>(value: T): T;

package/lib/browser/functions/deopt.js

@@ -0,0 +1,6 @@
+/**
+ * Workaround until https://github.com/BuilderIO/qwik/issues/5017 is fixed.
+ */
+export function deoptSignal(value) {
+    return value;
+}

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

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

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

@@ -0,0 +1,86 @@
+import { logger } from '../../../helpers/logger.js';
+import { set } from '../../set.js';
+import Interpreter from './acorn-interpreter.js';
+import { getFunctionArguments } from '../helpers.js';
+const processCode = (code) => {
+    return code.split('\n').map(line => {
+        const trimmed = line.trim();
+        // this async wrapper doesn't work in JS-interpreter, so we drop it.
+        if (line.includes('__awaiter'))
+            return undefined;
+        // we find all state setter expressions and append a call to setRootState afterwards
+        const isStateSetter = trimmed.startsWith('state.');
+        if (!isStateSetter)
+            return line;
+        const [lhs, rhs] = trimmed.split('=');
+        const setStr = lhs.replace('state.', '').trim();
+        const setExpr = `setRootState('${setStr}', ${rhs.trim()})`;
+        return `
+  ${line}
+  ${setExpr}
+  `;
+    }).filter(Boolean).join('\n');
+};
+const getJSONValName = (val) => val + 'JSON';
+export const runInEdge = ({ builder, context, event, rootState, localState, rootSetState, code }) => {
+    const state = {
+        ...rootState,
+        ...localState
+    };
+    const properties = getFunctionArguments({
+        builder,
+        context,
+        event,
+        state
+    });
+    /**
+     * Deserialize all properties from JSON strings to JS objects
+     */
+    const prependedCode = properties.map(([key]) => {
+        const jsonValName = getJSONValName(key);
+        return `var ${key} = ${jsonValName} === undefined ? undefined : JSON.parse(${jsonValName});`;
+    }).join('\n');
+    const cleanedCode = processCode(code);
+    if (cleanedCode === '') {
+        logger.warn('Skipping evaluation of empty code block.');
+        return;
+    }
+    const transformed = `
+function theFunction() {
+  ${prependedCode}
+
+  ${cleanedCode}
+}
+theFunction();
+`;
+    const setRootState = (prop, value) => {
+        const newState = set(state, prop, value);
+        rootSetState?.(newState);
+    };
+    const initFunc = function (interpreter, globalObject) {
+        /**
+         * serialize all function args to JSON strings
+         */
+        properties.forEach(([key, val]) => {
+            const jsonVal = JSON.stringify(val);
+            interpreter.setProperty(globalObject, getJSONValName(key), jsonVal);
+        });
+        /**
+         * Add a JavaScript function "setRootState" to the interpreter's global object, that will be called whenever a
+         * state property is set. This function will update the state object.
+         */
+        interpreter.setProperty(globalObject, 'setRootState', interpreter.createNativeFunction(setRootState));
+    };
+    try {
+        const myInterpreter = new Interpreter(transformed, initFunc);
+        myInterpreter.run();
+        const output = myInterpreter.pseudoToNative(myInterpreter.value);
+        return output;
+    }
+    catch (e) {
+        logger.warn('Custom code error in edge runtime. NOTE: your code must be ES5 JavaScript.', {
+            e
+        });
+        return;
+    }
+};

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

@@ -0,0 +1 @@
+export { runInEdge as evaluator } from './edge-runtime.js';

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

@@ -0,0 +1 @@
+export { runInEdge as evaluator } from './edge-runtime.js';