effect-start 0.26.0 → 0.28.0

package/dist/datastar/engine.js

@@ -0,0 +1,1000 @@
+import { aliasify, hasOwn, isHTMLOrSVG, isPojo, pathToObj, snake } from "./utils.js";
+/*********
+ * consts.ts
+ *********/
+const lol = /🖕JS_DS🚀/.source;
+export const DSP = lol.slice(0, 5);
+export const DSS = lol.slice(4);
+export const DATASTAR_FETCH_EVENT = "datastar-fetch";
+export const DATASTAR_SIGNAL_PATCH_EVENT = "datastar-signal-patch";
+const ReactiveFlags = {
+    None: 0,
+    Mutable: 1 << 0,
+    Watching: 1 << 1,
+    RecursedCheck: 1 << 2,
+    Recursed: 1 << 3,
+    Dirty: 1 << 4,
+    Pending: 1 << 5,
+};
+const EffectFlags = {
+    Queued: 1 << 6,
+};
+const currentPatch = [];
+const queuedEffects = [];
+let batchDepth = 0;
+let notifyIndex = 0;
+let queuedEffectsLength = 0;
+let prevSub;
+let activeSub;
+let version = 0;
+export const beginBatch = () => {
+    batchDepth++;
+};
+export const endBatch = () => {
+    if (!--batchDepth) {
+        flush();
+        dispatch();
+    }
+};
+export const startPeeking = (sub) => {
+    prevSub = activeSub;
+    activeSub = sub;
+};
+export const stopPeeking = () => {
+    activeSub = prevSub;
+    prevSub = undefined;
+};
+export const signal = (initialValue) => {
+    return signalOper.bind(0, {
+        previousValue: initialValue,
+        value_: initialValue,
+        flags_: 1,
+    });
+};
+const computedSymbol = Symbol("computed");
+export const computed = (getter) => {
+    const c = computedOper.bind(0, {
+        flags_: 17,
+        getter,
+    });
+    // @ts-ignore
+    c[computedSymbol] = 1;
+    return c;
+};
+export const effect = (fn) => {
+    const e = {
+        fn_: fn,
+        flags_: 2,
+    };
+    if (activeSub) {
+        link(e, activeSub);
+    }
+    startPeeking(e);
+    beginBatch();
+    try {
+        e.fn_();
+    }
+    finally {
+        endBatch();
+        stopPeeking();
+    }
+    return effectOper.bind(0, e);
+};
+const flush = () => {
+    while (notifyIndex < queuedEffectsLength) {
+        const effect = queuedEffects[notifyIndex];
+        queuedEffects[notifyIndex++] = undefined;
+        run(effect, (effect.flags_ &= ~EffectFlags.Queued));
+    }
+    notifyIndex = 0;
+    queuedEffectsLength = 0;
+};
+const update = (signal) => {
+    if ("getter" in signal) {
+        return updateComputed(signal);
+    }
+    return updateSignal(signal, signal.value_);
+};
+const updateComputed = (c) => {
+    startPeeking(c);
+    startTracking(c);
+    try {
+        const oldValue = c.value_;
+        return oldValue !== (c.value_ = c.getter(oldValue));
+    }
+    finally {
+        stopPeeking();
+        endTracking(c);
+    }
+};
+const updateSignal = (s, value) => {
+    s.flags_ = 1;
+    return s.previousValue !== (s.previousValue = value);
+};
+const notify = (e) => {
+    const flags = e.flags_;
+    if (!(flags & EffectFlags.Queued)) {
+        e.flags_ = flags | EffectFlags.Queued;
+        const subs = e.subs_;
+        if (subs) {
+            notify(subs.sub_);
+        }
+        else {
+            queuedEffects[queuedEffectsLength++] = e;
+        }
+    }
+};
+const run = (e, flags) => {
+    if (flags & 16 ||
+        (flags & 32 && checkDirty(e.deps_, e))) {
+        startPeeking(e);
+        startTracking(e);
+        beginBatch();
+        try {
+            e.fn_();
+        }
+        finally {
+            endBatch();
+            stopPeeking();
+            endTracking(e);
+        }
+        return;
+    }
+    if (flags & 32) {
+        e.flags_ = flags & ~32;
+    }
+    let link = e.deps_;
+    while (link) {
+        const dep = link.dep_;
+        const depFlags = dep.flags_;
+        if (depFlags & EffectFlags.Queued) {
+            run(dep, (dep.flags_ = depFlags & ~EffectFlags.Queued));
+        }
+        link = link.nextDep_;
+    }
+};
+const signalOper = (s, ...value) => {
+    if (value.length) {
+        if (s.value_ !== (s.value_ = value[0])) {
+            s.flags_ = 17;
+            const subs = s.subs_;
+            if (subs) {
+                propagate(subs);
+                if (!batchDepth) {
+                    flush();
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    const currentValue = s.value_;
+    if (s.flags_ & 16) {
+        if (updateSignal(s, currentValue)) {
+            const subs_ = s.subs_;
+            if (subs_) {
+                shallowPropagate(subs_);
+            }
+        }
+    }
+    if (activeSub) {
+        link(s, activeSub);
+    }
+    return currentValue;
+};
+const computedOper = (c) => {
+    const flags = c.flags_;
+    if (flags & 16 ||
+        (flags & 32 && checkDirty(c.deps_, c))) {
+        if (updateComputed(c)) {
+            const subs = c.subs_;
+            if (subs) {
+                shallowPropagate(subs);
+            }
+        }
+    }
+    else if (flags & 32) {
+        c.flags_ = flags & ~32;
+    }
+    if (activeSub) {
+        link(c, activeSub);
+    }
+    return c.value_;
+};
+const effectOper = (e) => {
+    let dep = e.deps_;
+    while (dep) {
+        dep = unlink(dep, e);
+    }
+    const sub = e.subs_;
+    if (sub) {
+        unlink(sub);
+    }
+    e.flags_ = 0;
+};
+const link = (dep, sub) => {
+    const prevDep = sub.depsTail_;
+    if (prevDep && prevDep.dep_ === dep) {
+        return;
+    }
+    const nextDep = prevDep ? prevDep.nextDep_ : sub.deps_;
+    if (nextDep && nextDep.dep_ === dep) {
+        nextDep.version_ = version;
+        sub.depsTail_ = nextDep;
+        return;
+    }
+    const prevSub = dep.subsTail_;
+    if (prevSub && prevSub.version_ === version && prevSub.sub_ === sub) {
+        return;
+    }
+    const newLink = (sub.depsTail_ =
+        dep.subsTail_ =
+            {
+                version_: version,
+                dep_: dep,
+                sub_: sub,
+                prevDep_: prevDep,
+                nextDep_: nextDep,
+                prevSub_: prevSub,
+            });
+    if (nextDep) {
+        nextDep.prevDep_ = newLink;
+    }
+    if (prevDep) {
+        prevDep.nextDep_ = newLink;
+    }
+    else {
+        sub.deps_ = newLink;
+    }
+    if (prevSub) {
+        prevSub.nextSub_ = newLink;
+    }
+    else {
+        dep.subs_ = newLink;
+    }
+};
+const unlink = (link, sub = link.sub_) => {
+    const dep_ = link.dep_;
+    const prevDep_ = link.prevDep_;
+    const nextDep_ = link.nextDep_;
+    const nextSub_ = link.nextSub_;
+    const prevSub_ = link.prevSub_;
+    if (nextDep_) {
+        nextDep_.prevDep_ = prevDep_;
+    }
+    else {
+        sub.depsTail_ = prevDep_;
+    }
+    if (prevDep_) {
+        prevDep_.nextDep_ = nextDep_;
+    }
+    else {
+        sub.deps_ = nextDep_;
+    }
+    if (nextSub_) {
+        nextSub_.prevSub_ = prevSub_;
+    }
+    else {
+        dep_.subsTail_ = prevSub_;
+    }
+    if (prevSub_) {
+        prevSub_.nextSub_ = nextSub_;
+    }
+    else if (!(dep_.subs_ = nextSub_)) {
+        if ("getter" in dep_) {
+            let toRemove = dep_.deps_;
+            if (toRemove) {
+                dep_.flags_ = 17;
+                do {
+                    toRemove = unlink(toRemove, dep_);
+                } while (toRemove);
+            }
+        }
+        else if (!("previousValue" in dep_)) {
+            effectOper(dep_);
+        }
+    }
+    return nextDep_;
+};
+const propagate = (link) => {
+    let next = link.nextSub_;
+    let stack;
+    top: while (true) {
+        const sub = link.sub_;
+        let flags = sub.flags_;
+        if (!(flags &
+            60)) {
+            sub.flags_ = flags | 32;
+        }
+        else if (!(flags & 12)) {
+            flags = 0;
+        }
+        else if (!(flags & 4)) {
+            sub.flags_ =
+                (flags & ~8) | 32;
+        }
+        else if (!(flags & 48) &&
+            isValidLink(link, sub)) {
+            sub.flags_ = flags | 40;
+            flags &= 1;
+        }
+        else {
+            flags = 0;
+        }
+        if (flags & 2) {
+            notify(sub);
+        }
+        if (flags & 1) {
+            const subSubs = sub.subs_;
+            if (subSubs) {
+                const nextSub = (link = subSubs).nextSub_;
+                if (nextSub) {
+                    stack = { value_: next, prev_: stack };
+                    next = nextSub;
+                }
+                continue;
+            }
+        }
+        if ((link = next)) {
+            next = link.nextSub_;
+            continue;
+        }
+        while (stack) {
+            link = stack.value_;
+            stack = stack.prev_;
+            if (link) {
+                next = link.nextSub_;
+                continue top;
+            }
+        }
+        break;
+    }
+};
+const startTracking = (sub) => {
+    version++;
+    sub.depsTail_ = undefined;
+    sub.flags_ =
+        (sub.flags_ & ~56) |
+            4;
+};
+const endTracking = (sub) => {
+    const depsTail_ = sub.depsTail_;
+    let toRemove = depsTail_ ? depsTail_.nextDep_ : sub.deps_;
+    while (toRemove) {
+        toRemove = unlink(toRemove, sub);
+    }
+    sub.flags_ &= ~4;
+};
+const checkDirty = (link, sub) => {
+    let stack;
+    let checkDepth = 0;
+    let dirty = false;
+    top: while (true) {
+        const dep = link.dep_;
+        const flags = dep.flags_;
+        if (sub.flags_ & 16) {
+            dirty = true;
+        }
+        else if ((flags & 17) ===
+            17) {
+            if (update(dep)) {
+                const subs = dep.subs_;
+                if (subs.nextSub_) {
+                    shallowPropagate(subs);
+                }
+                dirty = true;
+            }
+        }
+        else if ((flags & 33) ===
+            33) {
+            if (link.nextSub_ || link.prevSub_) {
+                stack = { value_: link, prev_: stack };
+            }
+            link = dep.deps_;
+            sub = dep;
+            ++checkDepth;
+            continue;
+        }
+        if (!dirty) {
+            const nextDep = link.nextDep_;
+            if (nextDep) {
+                link = nextDep;
+                continue;
+            }
+        }
+        while (checkDepth--) {
+            const firstSub = sub.subs_;
+            const hasMultipleSubs = firstSub.nextSub_;
+            if (hasMultipleSubs) {
+                link = stack.value_;
+                stack = stack.prev_;
+            }
+            else {
+                link = firstSub;
+            }
+            if (dirty) {
+                if (update(sub)) {
+                    if (hasMultipleSubs) {
+                        shallowPropagate(firstSub);
+                    }
+                    sub = link.sub_;
+                    continue;
+                }
+                dirty = false;
+            }
+            else {
+                sub.flags_ &= ~32;
+            }
+            sub = link.sub_;
+            if (link.nextDep_) {
+                link = link.nextDep_;
+                continue top;
+            }
+        }
+        return dirty;
+    }
+};
+const shallowPropagate = (link) => {
+    do {
+        const sub = link.sub_;
+        const flags = sub.flags_;
+        if ((flags & 48) ===
+            32) {
+            sub.flags_ = flags | 16;
+            if (flags & 2) {
+                notify(sub);
+            }
+        }
+    } while ((link = link.nextSub_));
+};
+const isValidLink = (checkLink, sub) => {
+    let link = sub.depsTail_;
+    while (link) {
+        if (link === checkLink) {
+            return true;
+        }
+        link = link.prevDep_;
+    }
+    return false;
+};
+export const getPath = (path) => {
+    let result = root;
+    const split = path.split(".");
+    for (const path of split) {
+        if (result == null || !hasOwn(result, path)) {
+            return;
+        }
+        result = result[path];
+    }
+    return result;
+};
+const deep = (value, prefix = "") => {
+    const isArr = Array.isArray(value);
+    if (isArr || isPojo(value)) {
+        const deepObj = (isArr ? [] : {});
+        for (const key in value) {
+            deepObj[key] = signal(deep(value[key], `${prefix + key}.`));
+        }
+        const keys = signal(0);
+        return new Proxy(deepObj, {
+            get(_, prop) {
+                if (!(prop === "toJSON" && !hasOwn(deepObj, prop))) {
+                    if (isArr && prop in Array.prototype) {
+                        keys();
+                        return deepObj[prop];
+                    }
+                    if (typeof prop === "symbol") {
+                        return deepObj[prop];
+                    }
+                    if (!hasOwn(deepObj, prop) || deepObj[prop]() == null) {
+                        deepObj[prop] = signal("");
+                        dispatch(prefix + prop, "");
+                        keys(keys() + 1);
+                    }
+                    return deepObj[prop]();
+                }
+            },
+            set(_, prop, newValue) {
+                const path = prefix + prop;
+                if (isArr && prop === "length") {
+                    const diff = deepObj[prop] - newValue;
+                    deepObj[prop] = newValue;
+                    if (diff > 0) {
+                        const patch = {};
+                        for (let i = newValue; i < deepObj[prop]; i++) {
+                            patch[i] = null;
+                        }
+                        dispatch(prefix.slice(0, -1), patch);
+                        keys(keys() + 1);
+                    }
+                }
+                else if (hasOwn(deepObj, prop)) {
+                    if (newValue == null) {
+                        delete deepObj[prop];
+                    }
+                    else if (hasOwn(newValue, computedSymbol)) {
+                        deepObj[prop] = newValue;
+                        dispatch(path, "");
+                    }
+                    else {
+                        const currentValue = deepObj[prop]();
+                        const pathStr = `${path}.`;
+                        if (isPojo(currentValue) && isPojo(newValue)) {
+                            for (const key in currentValue) {
+                                if (!hasOwn(newValue, key)) {
+                                    delete currentValue[key];
+                                    dispatch(pathStr + key, null);
+                                }
+                            }
+                            for (const key in newValue) {
+                                const nextVal = newValue[key];
+                                if (currentValue[key] !== nextVal) {
+                                    currentValue[key] = nextVal;
+                                }
+                            }
+                        }
+                        else if (deepObj[prop](deep(newValue, pathStr))) {
+                            dispatch(path, newValue);
+                        }
+                    }
+                }
+                else if (newValue != null) {
+                    if (hasOwn(newValue, computedSymbol)) {
+                        deepObj[prop] = newValue;
+                        dispatch(path, "");
+                    }
+                    else {
+                        deepObj[prop] = signal(deep(newValue, `${path}.`));
+                        dispatch(path, newValue);
+                    }
+                    keys(keys() + 1);
+                }
+                return true;
+            },
+            deleteProperty(_, prop) {
+                delete deepObj[prop];
+                keys(keys() + 1);
+                return true;
+            },
+            ownKeys() {
+                keys();
+                return Reflect.ownKeys(deepObj);
+            },
+            has(_, prop) {
+                keys();
+                return prop in deepObj;
+            },
+        });
+    }
+    return value;
+};
+const dispatch = (path, value) => {
+    if (path !== undefined && value !== undefined) {
+        currentPatch.push([path, value]);
+    }
+    if (!batchDepth && currentPatch.length) {
+        const detail = pathToObj(currentPatch);
+        currentPatch.length = 0;
+        document.dispatchEvent(new CustomEvent(DATASTAR_SIGNAL_PATCH_EVENT, {
+            detail,
+        }));
+    }
+};
+export const mergePatch = (patch, { ifMissing } = {}) => {
+    beginBatch();
+    for (const key in patch) {
+        if (patch[key] == null) {
+            if (!ifMissing) {
+                delete root[key];
+            }
+        }
+        else {
+            mergeInner(patch[key], key, root, "", ifMissing);
+        }
+    }
+    endBatch();
+};
+export const mergePaths = (paths, options) => mergePatch(pathToObj(paths), options);
+const mergeInner = (patch, target, targetParent, prefix, ifMissing) => {
+    if (isPojo(patch)) {
+        if (!(hasOwn(targetParent, target) &&
+            (isPojo(targetParent[target]) || Array.isArray(targetParent[target])))) {
+            targetParent[target] = {};
+        }
+        for (const key in patch) {
+            if (patch[key] == null) {
+                if (!ifMissing) {
+                    delete targetParent[target][key];
+                }
+            }
+            else {
+                mergeInner(patch[key], key, targetParent[target], `${prefix + target}.`, ifMissing);
+            }
+        }
+    }
+    else if (!(ifMissing && hasOwn(targetParent, target))) {
+        targetParent[target] = patch;
+    }
+};
+const toRegExp = (val) => typeof val === "string" ? RegExp(val.replace(/^\/|\/$/g, "")) : val;
+export const filtered = ({ include = /.*/, exclude = /(?!)/ } = {}, obj = root) => {
+    const includeRe = toRegExp(include);
+    const excludeRe = toRegExp(exclude);
+    const paths = [];
+    const stack = [[obj, ""]];
+    while (stack.length) {
+        const [node, prefix] = stack.pop();
+        for (const key in node) {
+            const path = prefix + key;
+            if (isPojo(node[key])) {
+                stack.push([node[key], `${path}.`]);
+            }
+            else if (includeRe.test(path) && !excludeRe.test(path)) {
+                paths.push([path, getPath(path)]);
+            }
+        }
+    }
+    return pathToObj(paths);
+};
+export const root = deep({});
+/*********
+ * engine.ts (plugin system)
+ *********/
+const url = "https://data-star.dev/errors";
+const error = (ctx, reason, metadata = {}) => {
+    Object.assign(metadata, ctx);
+    const e = new Error();
+    const r = snake(reason);
+    const q = new URLSearchParams({
+        metadata: JSON.stringify(metadata),
+    }).toString();
+    const c = JSON.stringify(metadata, null, 2);
+    e.message = `${reason}\nMore info: ${url}/${r}?${q}\nContext: ${c}`;
+    return e;
+};
+const actionPlugins = new Map();
+const attributePlugins = new Map();
+const watcherPlugins = new Map();
+export const actions = new Proxy({}, {
+    get: (_, prop) => actionPlugins.get(prop)?.apply,
+    has: (_, prop) => actionPlugins.has(prop),
+    ownKeys: () => Reflect.ownKeys(actionPlugins),
+    set: () => false,
+    deleteProperty: () => false,
+});
+const removals = new Map();
+const queuedAttributes = [];
+const queuedAttributeNames = new Set();
+const observedRoots = new WeakSet();
+export const attribute = (plugin) => {
+    queuedAttributes.push(plugin);
+    if (queuedAttributes.length === 1) {
+        setTimeout(() => {
+            for (const attribute of queuedAttributes) {
+                queuedAttributeNames.add(attribute.name);
+                attributePlugins.set(attribute.name, attribute);
+            }
+            queuedAttributes.length = 0;
+            apply();
+            queuedAttributeNames.clear();
+        });
+    }
+};
+export const action = (plugin) => {
+    actionPlugins.set(plugin.name, plugin);
+};
+document.addEventListener(DATASTAR_FETCH_EVENT, ((evt) => {
+    const plugin = watcherPlugins.get(evt.detail.type);
+    if (plugin) {
+        plugin.apply({
+            error: error.bind(0, {
+                plugin: { type: "watcher", name: plugin.name },
+                element: {
+                    id: evt.target.id,
+                    tag: evt.target.tagName,
+                },
+            }),
+        }, evt.detail.argsRaw);
+    }
+}));
+export const watcher = (plugin) => {
+    watcherPlugins.set(plugin.name, plugin);
+};
+const cleanupEls = (els) => {
+    for (const el of els) {
+        const elCleanups = removals.get(el);
+        if (elCleanups && removals.delete(el)) {
+            for (const attrCleanups of elCleanups.values()) {
+                for (const cleanup of attrCleanups.values()) {
+                    cleanup();
+                }
+            }
+        }
+    }
+};
+const aliasedIgnore = aliasify("ignore");
+const aliasedIgnoreAttr = `[${aliasedIgnore}]`;
+const shouldIgnore = (el) => el.hasAttribute(`${aliasedIgnore}__self`) || !!el.closest(aliasedIgnoreAttr);
+const applyEls = (els, onlyNew) => {
+    for (const el of els) {
+        if (!shouldIgnore(el)) {
+            for (const key in el.dataset) {
+                applyAttributePlugin(el, key.replace(/[A-Z]/g, "-$&").toLowerCase(), el.dataset[key], onlyNew);
+            }
+        }
+    }
+};
+const observe = (mutations) => {
+    for (const { target, type, attributeName, addedNodes, removedNodes } of mutations) {
+        if (type === "childList") {
+            for (const node of removedNodes) {
+                if (isHTMLOrSVG(node)) {
+                    cleanupEls([node]);
+                    cleanupEls(node.querySelectorAll("*"));
+                }
+            }
+            for (const node of addedNodes) {
+                if (isHTMLOrSVG(node)) {
+                    applyEls([node]);
+                    applyEls(node.querySelectorAll("*"));
+                }
+            }
+        }
+        else if (type === "attributes" &&
+            attributeName.startsWith("data-") &&
+            isHTMLOrSVG(target) &&
+            !shouldIgnore(target)) {
+            const key = attributeName.slice(5);
+            const value = target.getAttribute(attributeName);
+            if (value === null) {
+                const elCleanups = removals.get(target);
+                if (elCleanups) {
+                    const attrCleanups = elCleanups.get(key);
+                    if (attrCleanups) {
+                        for (const cleanup of attrCleanups.values()) {
+                            cleanup();
+                        }
+                        elCleanups.delete(key);
+                    }
+                }
+            }
+            else {
+                applyAttributePlugin(target, key, value);
+            }
+        }
+    }
+};
+const mutationObserver = new MutationObserver(observe);
+export const parseAttributeKey = (rawKey) => {
+    const [namePart, ...rawModifiers] = rawKey.split("__");
+    const [pluginName, key] = namePart.split(/:(.+)/);
+    const mods = new Map();
+    for (const rawMod of rawModifiers) {
+        const [label, ...mod] = rawMod.split(".");
+        mods.set(label, new Set(mod));
+    }
+    return { pluginName, key, mods };
+};
+export const isDocumentObserverActive = () => observedRoots.has(document.documentElement);
+export const apply = (root = document.documentElement, observeRoot = true) => {
+    if (isHTMLOrSVG(root)) {
+        applyEls([root], true);
+    }
+    applyEls(root.querySelectorAll("*"), true);
+    if (observeRoot) {
+        mutationObserver.observe(root, {
+            subtree: true,
+            childList: true,
+            attributes: true,
+        });
+        observedRoots.add(root);
+    }
+};
+const applyAttributePlugin = (el, attrKey, value, onlyNew) => {
+    const rawKey = attrKey;
+    const { pluginName, key, mods } = parseAttributeKey(rawKey);
+    const plugin = attributePlugins.get(pluginName);
+    if ((!onlyNew || queuedAttributeNames.has(pluginName)) && plugin) {
+        const ctx = {
+            el,
+            rawKey,
+            mods,
+            error: error.bind(0, {
+                plugin: { type: "attribute", name: plugin.name },
+                element: { id: el.id, tag: el.tagName },
+                expression: { rawKey, key, value },
+            }),
+            key,
+            value,
+            loadedPluginNames: {
+                actions: new Set(actionPlugins.keys()),
+                attributes: new Set(attributePlugins.keys()),
+            },
+            rx: undefined,
+        };
+        const keyReq = (plugin.requirement &&
+            (typeof plugin.requirement === "string" ? plugin.requirement : plugin.requirement.key)) ||
+            "allowed";
+        const valueReq = (plugin.requirement &&
+            (typeof plugin.requirement === "string" ? plugin.requirement : plugin.requirement.value)) ||
+            "allowed";
+        const keyProvided = key !== undefined && key !== null && key !== "";
+        const valueProvided = value !== undefined && value !== null && value !== "";
+        if (keyProvided) {
+            if (keyReq === "denied") {
+                throw ctx.error("KeyNotAllowed");
+            }
+        }
+        else if (keyReq === "must") {
+            throw ctx.error("KeyRequired");
+        }
+        if (valueProvided) {
+            if (valueReq === "denied") {
+                throw ctx.error("ValueNotAllowed");
+            }
+        }
+        else if (valueReq === "must") {
+            throw ctx.error("ValueRequired");
+        }
+        if (keyReq === "exclusive" || valueReq === "exclusive") {
+            if (keyProvided && valueProvided) {
+                throw ctx.error("KeyAndValueProvided");
+            }
+            if (!keyProvided && !valueProvided) {
+                throw ctx.error("KeyOrValueRequired");
+            }
+        }
+        const cleanups = new Map();
+        if (valueProvided) {
+            let cachedRx;
+            ctx.rx = (...args) => {
+                if (!cachedRx) {
+                    cachedRx = genRx(value, {
+                        returnsValue: plugin.returnsValue,
+                        argNames: plugin.argNames,
+                        cleanups,
+                    });
+                }
+                return cachedRx(el, ...args);
+            };
+        }
+        const cleanup = plugin.apply(ctx);
+        if (cleanup) {
+            cleanups.set("attribute", cleanup);
+        }
+        let elCleanups = removals.get(el);
+        if (elCleanups) {
+            const attrCleanups = elCleanups.get(rawKey);
+            if (attrCleanups) {
+                for (const oldCleanup of attrCleanups.values()) {
+                    oldCleanup();
+                }
+            }
+        }
+        else {
+            elCleanups = new Map();
+            removals.set(el, elCleanups);
+        }
+        elCleanups.set(rawKey, cleanups);
+    }
+};
+const genRx = (value, { returnsValue = false, argNames = [], cleanups = new Map() } = {}) => {
+    if (/^\s*(?:async\s+)?(?:\(.*?\)\s*=>|[\w$]+\s*=>|function\s*[\w$]*\s*\()/.test(value)) {
+        const userFn = Function(`return (${value.trim()})`)();
+        return (el, ...args) => {
+            const actionsProxy = new Proxy({}, {
+                get: (_, name) => (...actionArgs) => {
+                    const err = error.bind(0, {
+                        plugin: { type: "action", name },
+                        element: { id: el.id, tag: el.tagName },
+                        expression: { fnContent: value, value },
+                    });
+                    const fn = actions[name];
+                    if (fn)
+                        return fn({ el, evt: undefined, error: err, cleanups }, ...actionArgs);
+                    throw err("UndefinedAction");
+                },
+            });
+            const dataEvt = args[0] instanceof Event ? args[0] : new Event("datastar:expression");
+            Object.defineProperties(dataEvt, {
+                target: { value: el },
+                signals: { value: root },
+                actions: { value: actionsProxy },
+                window: { value: window },
+            });
+            try {
+                return userFn(dataEvt);
+            }
+            catch (e) {
+                console.error(e);
+                throw error({
+                    element: { id: el.id, tag: el.tagName },
+                    expression: { fnContent: value, value },
+                    error: e.message,
+                }, "ExecuteExpression");
+            }
+        };
+    }
+    let expr = "";
+    if (returnsValue) {
+        const statementRe = /(\/(\\\/|[^/])*\/|"(\\"|[^"])*"|'(\\'|[^'])*'|`(\\`|[^`])*`|\(\s*((function)\s*\(\s*\)|(\(\s*\))\s*=>)\s*(?:\{[\s\S]*?\}|[^;){]*)\s*\)\s*\(\s*\)|[^;])+/gm;
+        const statements = value.trim().match(statementRe);
+        if (statements) {
+            const lastIdx = statements.length - 1;
+            const last = statements[lastIdx].trim();
+            if (!last.startsWith("return")) {
+                statements[lastIdx] = `return (${last});`;
+            }
+            expr = statements.join(";\n");
+        }
+    }
+    else {
+        expr = value.trim();
+    }
+    const escaped = new Map();
+    const escapeRe = RegExp(`(?:${DSP})(.*?)(?:${DSS})`, "gm");
+    let counter = 0;
+    for (const match of expr.matchAll(escapeRe)) {
+        const k = match[1];
+        const v = `__escaped${counter++}`;
+        escaped.set(v, k);
+        expr = expr.replace(DSP + k + DSS, v);
+    }
+    expr = expr
+        .replace(/\$\['([a-zA-Z_$\d][\w$]*)'\]/g, "$$$1")
+        .replace(/\$([a-zA-Z_\d]\w*(?:[.-]\w+)*)/g, (_, signalName) => signalName.split(".").reduce((acc, part) => `${acc}['${part}']`, "$"));
+    expr = expr.replaceAll(/@([A-Za-z_$][\w$]*)\(/g, '__action("$1",evt,');
+    for (const [k, v] of escaped) {
+        expr = expr.replace(k, v);
+    }
+    try {
+        const fn = Function("el", "$", "__action", "evt", ...argNames, expr);
+        return (el, ...args) => {
+            const action = (name, evt, ...args) => {
+                const err = error.bind(0, {
+                    plugin: { type: "action", name },
+                    element: { id: el.id, tag: el.tagName },
+                    expression: {
+                        fnContent: expr,
+                        value,
+                    },
+                });
+                const fn = actions[name];
+                if (fn) {
+                    return fn({
+                        el,
+                        evt,
+                        error: err,
+                        cleanups,
+                    }, ...args);
+                }
+                throw err("UndefinedAction");
+            };
+            try {
+                return fn(el, root, action, undefined, ...args);
+            }
+            catch (e) {
+                console.error(e);
+                throw error({
+                    element: { id: el.id, tag: el.tagName },
+                    expression: {
+                        fnContent: expr,
+                        value,
+                    },
+                    error: e.message,
+                }, "ExecuteExpression");
+            }
+        };
+    }
+    catch (e) {
+        console.error(e);
+        throw error({
+            expression: {
+                fnContent: expr,
+                value,
+            },
+            error: e.message,
+        }, "GenerateExpression");
+    }
+};
+//# sourceMappingURL=engine.js.map