woby
Version:
A high-performance framework with fine-grained observable/signal-based reactivity for building rich applications.
1,389 lines • 53 kB
JavaScript
"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const setters = require("./setters-CMvyty0B.cjs");
const render_to_string = require("./render_to_string-CoO3rHSR.cjs");
const root = require("./root-B1uuIGIw.cjs");
const runtime = require("./create_element-BUG6undN.cjs");
function mergeStyles(style = {}, css = "") {
const re = /([^:;]+)\s*:\s*([^;(]+(?:\(.*?\))?);?/igm;
const genObj = (css2 = "") => {
let match;
if (setters.isObject(css2))
return css2;
else {
const style2 = {};
while (match = re.exec(css2)) {
const [, property, value] = match;
const trimmedProperty = property.trim();
const trimmedValue = value.trim();
style2[trimmedProperty] = trimmedValue;
}
return style2;
}
};
const sty = genObj(style);
return Object.assign(sty, genObj(css));
}
var CmdType;
(function(CmdType2) {
CmdType2[CmdType2["Call"] = 0] = "Call";
CmdType2[CmdType2["Set"] = 1] = "Set";
CmdType2[CmdType2["Get"] = 2] = "Get";
CmdType2[CmdType2["Constructor"] = 3] = "Constructor";
})(CmdType || (CmdType = {}));
var SerializeType;
(function(SerializeType2) {
SerializeType2[SerializeType2["Primitive"] = 0] = "Primitive";
SerializeType2[SerializeType2["Object"] = 1] = "Object";
})(SerializeType || (SerializeType = {}));
var ArgEnum;
(function(ArgEnum2) {
ArgEnum2[ArgEnum2["Primitive"] = 0] = "Primitive";
ArgEnum2[ArgEnum2["Object"] = 1] = "Object";
ArgEnum2[ArgEnum2["Callback"] = 2] = "Callback";
ArgEnum2[ArgEnum2["ObjectProperty"] = 3] = "ObjectProperty";
})(ArgEnum || (ArgEnum = {}));
const __TargetSymbol = Symbol("TARGET");
const __ObjectSymbol = Symbol("ID");
const __ArgsSymbol = Symbol("ARGS");
const __IsViaSymbol = Symbol("IsVia");
const IgnoreSymbols = {
[__ArgsSymbol]: __ArgsSymbol,
[__IsViaSymbol]: __IsViaSymbol
};
class ViaClass {
constructor() {
this.finalizationRegistry = typeof FinalizationRegistry === "undefined" ? null : new FinalizationRegistry(this.FinalizeID.bind(this));
this.finalizeTimerId = -1;
this.finalizeIntervalMs = 10;
this.finalizeIdQueue = [];
this.nextObjectId = 1;
this.queue = [];
this.nextGetId = 0;
this.pendingGetResolves = /* @__PURE__ */ new Map();
this.nextFlushId = 0;
this.pendingFlushResolves = /* @__PURE__ */ new Map();
this.isPendingFlush = false;
this.nextCallbackId = 0;
this.callbackToId = /* @__PURE__ */ new Map();
this.idToCallback = /* @__PURE__ */ new Map();
if (!this.finalizationRegistry)
console.warn("[Via.js] No WeakRefs support - will leak memory");
}
FinalizeID(id) {
this.finalizeIdQueue.push(id);
if (this.finalizeTimerId === -1)
this.finalizeTimerId = setTimeout(this.CleanupIDs.bind(this), this.finalizeIntervalMs);
}
CleanupIDs() {
this.finalizeTimerId = -1;
this.postMessage({
"type": "cleanup",
"ids": this.finalizeIdQueue
});
this.finalizeIdQueue.length = 0;
}
getNextObjectId() {
return this.nextObjectId++;
}
addToQueue(d) {
this.queue.push(d);
if (!this.isPendingFlush) {
this.isPendingFlush = true;
Promise.resolve().then(this.flush.bind(this));
}
}
// Post the queue to the receiver. Returns a promise which resolves when the receiver
// has finished executing all the commands.
flush() {
this.isPendingFlush = false;
if (!this.queue.length)
return Promise.resolve();
const flushId = this.nextFlushId++;
this.postMessage({
"type": "cmds",
"cmds": this.queue,
"flushId": flushId
});
this.queue.length = 0;
return new Promise((resolve) => {
this.pendingFlushResolves.set(flushId, resolve);
});
}
// Called when a message received from the receiver
onMessage(data) {
switch (data.type) {
case "done":
this.onDone(data);
break;
case "callback":
this.onCallback(data);
break;
default:
throw new Error("invalid message type: " + data.type);
}
}
// Called when the receiver has finished a batch of commands passed by a flush.
onDone(data) {
for (const [getId, valueData] of data.getResults) {
const resolve = this.pendingGetResolves.get(getId);
if (!resolve)
throw new Error("invalid get id");
this.pendingGetResolves.delete(getId);
resolve(this.unwrapArg(valueData));
}
const flushId = data.flushId;
const flushResolve = this.pendingFlushResolves.get(flushId);
if (!flushResolve)
throw new Error("invalid flush id");
this.pendingFlushResolves.delete(flushId);
flushResolve();
}
// Called when a callback is invoked on the receiver and this was forwarded to the controller.
onCallback(data) {
const func = this.idToCallback.get(data.id);
if (!func)
throw new Error("invalid callback id");
const args = data.args.map(this.unwrapArg.bind(this));
func(...args);
}
getCallbackId(func) {
let id = this.callbackToId.get(func);
if (typeof id === "undefined") {
id = this.nextCallbackId++;
this.callbackToId.set(func, id);
this.idToCallback.set(id, func);
}
return id;
}
getIdToCallback(id) {
return this.idToCallback.get(id);
}
viaObjectHandler() {
const THIS = this;
return {
get(target, property, receiver) {
if (property === __ObjectSymbol)
return target[__ObjectSymbol];
else if (IgnoreSymbols[property])
return target[IgnoreSymbols[property]];
return THIS.makeProperty(target[__ObjectSymbol], [property]);
},
set(target, property, value, receiver) {
if (IgnoreSymbols[property])
target[IgnoreSymbols[property]] = value;
else if (typeof property === "symbol")
debugger;
else
THIS.addToQueue([1, target[__ObjectSymbol], [property], THIS.wrapArg(value)]);
return true;
}
};
}
ViaPropertyHandler() {
const THIS = this;
return {
get(target, property, receiver) {
if (property === __TargetSymbol)
return target;
if (IgnoreSymbols[property])
return target[property];
const nextCache = target._nextCache;
const existing = nextCache.get(property);
if (existing)
return existing;
const path = target._path.slice(0);
path.push(property);
const ret = THIS.makeProperty(target[__ObjectSymbol], path);
nextCache.set(property, ret);
return ret;
},
set(target, property, value, receiver) {
if (IgnoreSymbols[property])
target[property] = value;
else {
const path = target._path.slice(0);
path.push(property);
THIS.addToQueue([CmdType.Set, target[__ObjectSymbol], path, THIS.wrapArg(value)]);
}
return true;
},
apply(target, thisArg, argumentsList) {
const returnObjectId = THIS.getNextObjectId();
const args = argumentsList.map(THIS.wrapArg.bind(THIS));
target[__ArgsSymbol] = args.map(toArg);
THIS.addToQueue([CmdType.Call, target[__ObjectSymbol], target._path, args, returnObjectId]);
return THIS._MakeObject(returnObjectId);
},
construct(target, argumentsList, newTarget) {
const returnObjectId = THIS.getNextObjectId();
const args = argumentsList.map(THIS.wrapArg.bind(THIS));
target[__ArgsSymbol] = args.map(toArg);
THIS.addToQueue([CmdType.Constructor, target[__ObjectSymbol], target._path, args, returnObjectId]);
return THIS._MakeObject(returnObjectId);
}
};
}
_MakeObject(id) {
const func = function() {
};
func[__ObjectSymbol] = id;
func[__IsViaSymbol] = true;
const ret = new Proxy(func, this.viaObjectHandler());
if (this.finalizationRegistry)
this.finalizationRegistry.register(ret, id);
return ret;
}
// Wrap an argument to a small array representing the value, object, property or callback for
// posting to the receiver.
wrapArg(arg, _i, _a) {
if (typeof arg === "function") {
const objectId = arg[__ObjectSymbol];
if (typeof objectId === "number")
return [ArgEnum.Object, objectId];
const propertyTarget = arg[__TargetSymbol];
if (propertyTarget)
return [ArgEnum.ObjectProperty, propertyTarget[__ObjectSymbol], propertyTarget._path];
return [ArgEnum.Callback, this.getCallbackId(arg)];
} else if (CanStructuredClone$1(arg)) {
return [ArgEnum.Primitive, arg];
} else
throw new Error("invalid argument");
}
/**
* Unwrap an argument for a callback sent by the receiver.
* @param arr
* @returns
*/
unwrapArg(arr) {
switch (arr[0]) {
case 0:
return arr[1];
case 1:
return this._MakeObject(arr[1]);
default:
throw new Error("invalid arg type");
}
}
// Add a command to the queue representing a get request.
addGet(objectId, path) {
const getId = this.nextGetId++;
this.addToQueue([2, getId, objectId, path]);
return new Promise((resolve) => {
this.pendingGetResolves.set(getId, resolve);
});
}
// Return a promise that resolves with the real value of a property, e.g. get(via.document.title).
// This involves a message round-trip, but multiple gets can be requested in parallel, and they will
// all be processed in the same round-trip.
get(proxy) {
if (typeof proxy === "function") {
const objectId = proxy[__ObjectSymbol];
if (typeof objectId === "number")
return this.addGet(objectId, null);
const target = proxy[__TargetSymbol];
if (target)
return this.addGet(target[__ObjectSymbol], target._path);
}
return Promise.resolve(proxy);
}
makeProperty(objectId, path) {
const func = function() {
};
func[__ObjectSymbol] = objectId;
func[__IsViaSymbol] = true;
func._path = path;
func._nextCache = /* @__PURE__ */ new Map();
return new Proxy(func, this.ViaPropertyHandler());
}
}
if (!self.Via)
self.Via = new ViaClass();
self.via = self.Via._MakeObject(0);
self.get = self.Via.get.bind(self.Via);
const isProxy = (proxy) => {
return proxy == null ? false : !!proxy[__IsViaSymbol];
//!!proxy[Symbol.for("__isProxy")]
};
function CanStructuredClone$1(o) {
const type = typeof o;
return type === "undefined" || o === null || type === "boolean" || type === "number" || type === "bigint" || type === "string" || o instanceof Blob || o instanceof ArrayBuffer || o instanceof ImageData || (Array.isArray(o) && o.every((oo) => isProxy(oo)) || Object.keys(o).every((k) => CanStructuredClone$1(o[k])));
}
const toArg = (arg, _i, _a) => arg[1];
const attributesBoolean = /* @__PURE__ */ new Set(["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"]);
const attributeCamelCasedRe = /e(r[HRWrv]|[Vawy])|Con|l(e[Tcs]|c)|s(eP|y)|a(t[rt]|u|v)|Of|Ex|f[XYa]|gt|hR|d[Pg]|t[TXYd]|[UZq]/;
const attributesCache = {};
const uppercaseRe = /[A-Z]/g;
const normalizeKeySvg = (key) => attributesCache[key] || (attributesCache[key] = attributeCamelCasedRe.test(key) ? key : key.replace(uppercaseRe, (char) => `-${char.toLowerCase()}`));
const isNil = (value) => value === null || value === void 0;
const toKey = (key) => key === "xlinkHref" || key === "xlink:href" ? "href" : normalizeKeySvg(key);
class ViaReceiverClass {
constructor() {
this.idMap = /* @__PURE__ */ new Map([[0, self]]);
this.nextObjectId = -1;
this.callbackToId = /* @__PURE__ */ new Map();
this.idToCallback = /* @__PURE__ */ new Map();
}
// Wrap an argument. This is used for sending values back to the controller. Anything that can be directly
// posted is sent as-is, but any kind of object is represented by its object ID instead.
WrapArg(arg) {
if (CanStructuredClone(arg))
return [SerializeType.Primitive, arg];
else
return [SerializeType.Object, this.ObjectToId(arg)];
}
// Get the real object from an ID.
IdToObject(id) {
const ret = this.idMap.get(id);
if (typeof ret === "undefined")
throw new Error("missing object id: " + id);
return ret;
}
// Allocate new ID for an object on the receiver side.
// The receiver uses negative IDs to prevent ID collisions with the controller.
ObjectToId(object) {
const id = this.nextObjectId--;
this.idMap.set(id, object);
return id;
}
// Get the real value from an ID and a property path, e.g. object ID 0, path ["document", "title"]
// will return window.document.title.
IdToObjectProperty(id, path) {
const ret = this.idMap.get(id);
if (typeof ret === "undefined")
throw new Error("missing object id: " + id);
let base = ret;
for (let i = 0, len = path.length; i < len; ++i)
base = base[path[i]];
return base;
}
// Get a shim function for a given callback ID. This creates a new function that forwards the
// call with its arguments to the controller, where it will run the real callback.
// Callback functions are not re-used to allow them to be garbage collected normally.
GetCallbackShim(id) {
if (this.idToCallback.has(id)) {
return this.idToCallback.get(id);
}
const f = (...args) => this.postMessage({
"type": "callback",
"id": id,
"args": args.map(this.WrapArg.bind(this))
});
this.callbackToId.set(f, id);
this.idToCallback.set(id, f);
return f;
}
// Unwrap an argument sent from the controller. Arguments are transported as small arrays indicating
// the type and any object IDs/property paths, so they can be looked up on the receiver side.
UnwrapArg(arr) {
switch (arr[0]) {
case ArgEnum.Primitive:
return arr[1];
case ArgEnum.Object:
return this.IdToObject(arr[1]);
case ArgEnum.Callback:
return this.GetCallbackShim(arr[1]);
case ArgEnum.ObjectProperty:
return this.IdToObjectProperty(arr[1], arr[2]);
default:
throw new Error("invalid arg type");
}
}
// Called when receiving a message from the controller.
OnMessage(data) {
switch (data.type) {
case "cmds":
this.OnCommandsMessage(data);
break;
case "cleanup":
this.OnCleanupMessage(data);
break;
default:
console.error("Unknown message type: " + data.type);
break;
}
}
OnCommandsMessage(data) {
const getResults = [];
data.cmds.forEach((cmd, i, a) => {
this.RunCommand(cmd, getResults);
});
this.postMessage({
type: "done",
flushId: data.flushId,
getResults
});
}
RunCommand(arr, getResults) {
const type = arr[0];
switch (type) {
case CmdType.Call:
this.ViaCall(arr[1], arr[2], arr[3], arr[4]);
break;
case CmdType.Set:
this.ViaSet(arr[1], arr[2], arr[3]);
break;
case CmdType.Get:
this.ViaGet(arr[1], arr[2], arr[3], getResults);
break;
case CmdType.Constructor:
this.ViaConstruct(arr[1], arr[2], arr[3], arr[4]);
break;
default:
throw new Error("invalid cmd type: " + type);
}
}
ViaCall(objectId, path, argsData, returnObjectId) {
const obj = this.IdToObject(objectId);
const args = argsData.map(this.UnwrapArg.bind(this));
const methodName = path[path.length - 1];
let base = obj;
for (let i = 0, len = path.length - 1; i < len; ++i)
base = base[path[i]];
if (methodName === "removeEventListener") {
const key = argsData[0][1];
const id = argsData[1][1];
console.log("removeEventListener", key, id);
const f = this.idToCallback.get(id);
const ret = base.removeEventListener(key, f);
this.idToCallback.delete(id);
this.callbackToId.delete(f);
this.idMap.set(returnObjectId, ret);
} else if (methodName === "setAttribute" && (args[0] === "tabIndex" || base["isSVG"])) {
if (args[0] === "tabIndex") ;
else {
const ret = base.setAttribute(toKey(args[0]), args[1]);
this.idMap.set(returnObjectId, ret);
}
} else {
const ret = base[methodName](...args.map((a) => Array.isArray(a) ? [].slice.call(a) : a).flat());
this.idMap.set(returnObjectId, ret);
}
}
ViaConstruct(objectId, path, argsData, returnObjectId) {
const obj = this.IdToObject(objectId);
const args = argsData.map(this.UnwrapArg.bind(this));
const methodName = path[path.length - 1];
let base = obj;
for (let i = 0, len = path.length - 1; i < len; ++i)
base = base[path[i]];
const ret = new base[methodName](...args);
this.idMap.set(returnObjectId, ret);
}
ViaSet(objectId, path, valueData) {
const obj = this.IdToObject(objectId);
const value = this.UnwrapArg(valueData);
const propertyName = path[path.length - 1];
let base = obj;
for (let i = 0, len = path.length - 1; i < len; ++i)
base = base[path[i]];
if (propertyName === "tabIndex" && typeof value === "undefined")
base.removeAttribute("tabIndex");
else if (base["isSVG"]) {
const key = toKey(propertyName);
if (isNil(value) || value === false && attributesBoolean.has(key))
base.removeAttribute(key);
else
base.setAttribute(key, String(value));
} else
base[propertyName] = value;
}
ViaGet(getId, objectId, path, getResults) {
const obj = this.IdToObject(objectId);
if (path === null) {
getResults.push([getId, this.WrapArg(obj)]);
return;
}
const propertyName = path[path.length - 1];
let base = obj;
for (let i = 0, len = path.length - 1; i < len; ++i)
base = base[path[i]];
const value = base["isSVG"] ? base.getAttribute(toKey(propertyName)) : base[propertyName];
getResults.push([getId, this.WrapArg(value)]);
}
OnCleanupMessage(data) {
for (const id of data.ids)
this.idMap.delete(id);
}
}
function CanStructuredClone(o) {
const type = typeof o;
return type === "undefined" || o === null || type === "boolean" || type === "number" || type === "bigint" || type === "string" || o instanceof Blob || o instanceof ArrayBuffer || o instanceof ImageData;
}
self.ViaReceiver = new ViaReceiverClass();
if (typeof via !== "undefined")
var document$1 = via.document;
document$1.createComment;
const createHTMLNode = document$1.createElement;
const createSVGNode = (name) => document$1.createElementNS("http://www.w3.org/2000/svg", name);
const createText = document$1.createTextNode;
document$1.createDocumentFragment;
const HTMLValue = Symbol("HtmlValue");
IgnoreSymbols[HTMLValue] = HTMLValue;
const resolveChild = (value, setter, _dynamic, stack) => {
var _a, _b;
const updateElement = (e, f, v, pv) => {
e.textContent = "";
if (setters.isArray(v)) {
e[HTMLValue] = "array";
if (!f)
e.parentElement.replaceChildren(e, ...setters.toArray(v));
return [e, ...v];
} else {
const useE = () => {
if (pv) {
switch (pv[0][HTMLValue]) {
case "element":
pv[0].replaceWith(e);
break;
case "primitive":
case "array": {
pv.slice(1).forEach((p) => p.remove());
break;
}
}
}
};
if (typeof v === "symbol") {
e[HTMLValue] = "symbol";
if (!f)
e.parentElement.replaceChildren(e);
return [e];
} else {
if (setters.isProxy(v)) {
e[HTMLValue] = "element";
v[HTMLValue] = "element";
if (pv) {
switch (pv[0][HTMLValue]) {
case "element":
pv[0].replaceWith(v);
break;
case "primitive":
case "array":
case "symbol":
case "null":
pv[0].parentElement.replaceChildren(...setters.toArray(v));
break;
}
}
return [v];
} else if (!(v === void 0 || v === null)) {
e[HTMLValue] = "primitive";
e.textContent = setters.fixBigInt(v);
useE();
return [
e
/* , fixBigInt(v) */
];
} else {
e[HTMLValue] = "null";
useE();
return [e];
}
}
}
};
if (setters.isProxy(value)) {
return value;
} else if (setters.isArray(value)) {
const [values, hasObservables] = resolveArraysAndStatics(value);
values[setters.SYMBOL_UNCACHED] = value[setters.SYMBOL_UNCACHED];
if (hasObservables) {
const e = createText("");
let f = true;
let v;
setters.useRenderEffect(() => {
const pv = v;
v = values.map((v2) => resolveChild(v2, null, false, stack)).filter((v2) => typeof v2 !== "undefined");
v = updateElement(e, f, v, pv);
f = false;
}, stack);
return v;
} else {
const vs = values.map((v) => resolveChild(v, null, false, stack)).filter((v) => typeof v !== "undefined");
return vs;
}
} else if (setters.isFunction(value)) {
if (setters.SYMBOL_UNTRACKED_UNWRAPPED in value || setters.SYMBOL_OBSERVABLE_FROZEN in value || ((_b = (_a = value[setters.SYMBOL_OBSERVABLE_READABLE]) == null ? void 0 : _a.parent) == null ? void 0 : _b.disposed)) {
(value[setters.SYMBOL_OBSERVABLE_READABLE] ?? value[setters.SYMBOL_OBSERVABLE_WRITABLE]).stack = stack;
resolveChild(value(), setter, _dynamic, stack);
} else {
const e = createText("");
let f = true;
let v;
setters.useRenderEffect((stack2) => {
const pv = v;
(value[setters.SYMBOL_OBSERVABLE_READABLE] ?? value[setters.SYMBOL_OBSERVABLE_WRITABLE]).stack = stack2;
v = resolveChild(value(), null, false, stack2);
v = updateElement(e, f, v, pv);
f = false;
}, stack);
return v;
}
} else {
return value;
}
};
const resolveClass = (classes, resolved = {}) => {
if (setters.isString(classes)) {
classes.split(/\s+/g).filter(Boolean).filter((cls) => {
resolved[cls] = true;
});
} else if (setters.isFunction(classes)) {
resolveClass(classes(), resolved);
} else if (setters.isArray(classes)) {
classes.forEach((cls) => {
resolveClass(cls, resolved);
});
} else if (classes) {
for (const key in classes) {
const value = classes[key];
const isActive = !!setters.get(value);
if (!isActive) continue;
resolved[key] = true;
}
}
return resolved;
};
const resolveStyle = (styles, resolved = {}) => {
if (setters.isString(styles)) {
return styles;
} else if (setters.isFunction(styles)) {
return resolveStyle(styles(), resolved);
} else if (setters.isArray(styles)) {
styles.forEach((style) => {
resolveStyle(style, resolved);
});
} else if (styles) {
for (const key in styles) {
const value = styles[key];
resolved[key] = setters.get(value);
}
}
return resolved;
};
const resolveArraysAndStatics = /* @__PURE__ */ (() => {
const DUMMY_RESOLVED = [];
const resolveArraysAndStaticsInner = (values, resolved, hasObservables) => {
for (let i = 0, l = values.length; i < l; i++) {
const value = values[i];
const type = typeof value;
if (type === "string" || type === "number" || type === "bigint") {
if (resolved === DUMMY_RESOLVED) resolved = values.slice(0, i);
resolved.push(createText(setters.fixBigInt(value)));
} else if (type === "object" && setters.isArray(value)) {
if (resolved === DUMMY_RESOLVED) resolved = values.slice(0, i);
hasObservables = resolveArraysAndStaticsInner(value, resolved, hasObservables)[1];
} else if (type === "function" && setters.isObservable(value)) {
if (resolved !== DUMMY_RESOLVED) resolved.push(value);
hasObservables = true;
} else {
if (resolved !== DUMMY_RESOLVED) resolved.push(value);
}
}
if (resolved === DUMMY_RESOLVED) resolved = values;
return [resolved, hasObservables];
};
return (values) => {
return resolveArraysAndStaticsInner(values, DUMMY_RESOLVED, false);
};
})();
const setAttributeStatic = /* @__PURE__ */ (() => {
const attributesBoolean2 = /* @__PURE__ */ new Set(["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"]);
return (element, key, value) => {
if (setters.isNil(value) || value === false && attributesBoolean2.has(key)) {
element.removeAttribute(key);
} else {
value = value === true ? "" : String(value);
element.setAttribute(key, value);
}
};
})();
const setAttribute = (element, key, value, stack) => {
var _a, _b;
if (setters.isFunction(value)) {
if (setters.isObservable(value)) {
if (setters.isObservable(value) && ((_b = (_a = value[setters.SYMBOL_OBSERVABLE_WRITABLE]) == null ? void 0 : _a.options) == null ? void 0 : _b.toHtml)) {
setters.useRenderEffect(() => {
const unwrappedValue = value();
const options = value[setters.SYMBOL_OBSERVABLE_WRITABLE].options;
const htmlValue = options.toHtml(unwrappedValue);
setAttributeStatic(element, key, htmlValue);
}, stack);
} else {
setters.useRenderEffect(() => {
setAttributeStatic(element, key, value());
}, stack);
}
} else {
setAttributeStatic(element, key, value());
}
} else {
setAttributeStatic(element, key, value);
}
};
const setChildStatic = (parent, child, dynamic, stack) => {
if (setters.isVoidChild(child)) return;
if (setters.isArray(child)) {
const children = setters.isArray(child) ? child : [child];
const cs = children.map((c) => resolveChild(c, null, false, stack)).flat(Infinity);
parent.replaceChildren(...cs);
} else {
const c = resolveChild(child, null, false, stack);
parent.replaceChildren(...[c].flat(Infinity));
}
};
const setChild = (parent, child, stack) => {
setChildStatic(parent, child, false, stack);
};
const setClassStatic = setters.classesToggle;
const setClass = (element, key, value, stack) => {
if (setters.isFunction(value)) {
if (setters.isObservable(value)) {
setters.useRenderEffect(() => {
setClassStatic(element, key, value());
}, stack);
} else {
setClassStatic(element, key, value());
}
} else {
setClassStatic(element, key, value);
}
};
const setClassBooleanStatic = (element, value, key, keyPrev) => {
if (keyPrev && keyPrev !== true) {
setClassStatic(element, keyPrev, false);
}
if (key && key !== true) {
setClassStatic(element, key, value);
}
};
const setClassBoolean = (element, value, key, stack) => {
if (setters.isFunction(key)) {
if (setters.isObservable(key)) {
let keyPrev;
setters.useRenderEffect(() => {
const keyNext = key();
setClassBooleanStatic(element, value, keyNext, keyPrev);
keyPrev = keyNext;
}, stack);
} else {
setClassBooleanStatic(element, value, key());
}
} else {
setClassBooleanStatic(element, value, key);
}
};
const setClassesStatic = (element, object, objectPrev, stack) => {
if (setters.isString(object)) {
if (setters.isSVG(element)) {
element.setAttribute("class", object);
} else {
element.className = object;
}
} else {
if (objectPrev) {
if (setters.isString(objectPrev)) {
if (objectPrev) {
if (setters.isSVG(element)) {
element.setAttribute("class", "");
} else {
element.className = "";
}
}
} else if (setters.isArray(objectPrev)) {
objectPrev = setters.store(objectPrev, {});
for (let i = 0, l = objectPrev.length; i < l; i++) {
if (!objectPrev[i]) continue;
setClassBoolean(element, false, objectPrev[i], stack);
}
} else {
objectPrev = setters.store(objectPrev, {});
for (const key in objectPrev) {
if (object && key in object) continue;
setClass(element, key, false, stack);
}
}
}
if (setters.isArray(object)) {
if (setters.isStore(object)) {
for (let i = 0, l = object.length; i < l; i++) {
const fn = setters.untrack(() => setters.isFunction(object[i]) ? object[i] : object[setters.SYMBOL_STORE_OBSERVABLE](String(i)));
setClassBoolean(element, true, fn, stack);
}
} else {
for (let i = 0, l = object.length; i < l; i++) {
if (!object[i]) continue;
setClassBoolean(element, true, object[i], stack);
}
}
} else {
if (setters.isStore(object)) {
for (const key in object) {
const fn = setters.untrack(() => setters.isFunction(object[key]) ? object[key] : object[setters.SYMBOL_STORE_OBSERVABLE](key));
setClass(element, key, fn, stack);
}
} else {
for (const key in object) {
setClass(element, key, object[key], stack);
}
}
}
}
};
const setClasses = (element, object, stack) => {
if (setters.isFunction(object) || setters.isArray(object)) {
let objectPrev;
setters.useRenderEffect(() => {
const objectNext = resolveClass(object);
setClassesStatic(element, objectNext, objectPrev, stack);
objectPrev = objectNext;
}, stack);
} else {
setClassesStatic(element, object, null, stack);
}
};
const setDirective = (element, directive, args) => {
const symbol = setters.SYMBOLS_DIRECTIVES[directive] || Symbol();
const data = setters.context(symbol) || setters.DIRECTIVES[symbol];
if (!data) throw new Error(`Directive "${directive}" not found`);
const call = () => data.fn(element, ...setters.castArray(args));
const stack = new Error();
if (data.immediate) {
call();
} else {
setters.useMicrotask(call, stack);
}
};
const setEventStatic = /* @__PURE__ */ (() => {
return (element, event, value) => {
element[event] = value;
};
})();
const setEvent = (element, event, value) => {
setEventStatic(element, event, value);
};
const setHTMLStatic = (element, value) => {
element.innerHTML = String(setters.isNil(value) ? "" : value);
};
const setHTML = (element, value, stack) => {
setters.useRenderEffect(() => {
setHTMLStatic(element, setters.get(setters.get(value).__html));
}, stack);
};
const setPropertyStatic = (element, key, value) => {
if (key === "tabIndex" && setters.isBoolean(value)) {
value = value ? 0 : void 0;
}
if (key === "value") {
if (element.tagName === "PROGRESS") {
value ?? (value = null);
} else if (element.tagName === "SELECT" && !element["_$inited"]) {
element["_$inited"] = true;
queueMicrotask(() => element[key] = value);
}
}
try {
element[key] = value;
} catch {
setAttributeStatic(element, key, value);
}
};
const setProperty = (element, key, value, stack) => {
if (setters.isFunction(value) && setters.isFunctionReactive(value)) {
if (setters.isObservable(value)) {
setters.useRenderEffect(() => {
setPropertyStatic(element, key, value());
}, stack);
} else {
setPropertyStatic(element, key, setters.get(value));
}
} else {
setPropertyStatic(element, key, setters.get(value));
}
};
const setRef = (element, value) => {
if (setters.isNil(value)) return;
const values = setters.flatten(setters.castArray(value)).filter(Boolean);
if (!values.length) return;
const stack = new Error();
setters.useMicrotask(() => setters.untrack(() => values.forEach((value2) => value2 == null ? void 0 : value2(element))), stack);
};
const setStyleStatic = /* @__PURE__ */ (() => {
const propertyNonDimensionalRe = /^(-|f[lo].*[^se]$|g.{5,}[^ps]$|z|o[pr]|(W.{5})?[lL]i.*(t|mp)$|an|(bo|s).{4}Im|sca|m.{6}[ds]|ta|c.*[st]$|wido|ini)/i;
const propertyNonDimensionalCache = {};
return (element, key, value) => {
if (key.charCodeAt(0) === 45) {
if (setters.isNil(value)) {
element.style.removeProperty(key);
} else {
element.style.setProperty(key, String(value));
}
} else if (setters.isNil(value)) {
element.style[key] = null;
} else {
element.style[key] = setters.isString(value) || (propertyNonDimensionalCache[key] || (propertyNonDimensionalCache[key] = propertyNonDimensionalRe.test(key))) ? value : `${value}px`;
}
};
})();
const setStyle = (element, key, value, stack) => {
if (setters.isFunction(value) && setters.isFunctionReactive(value)) {
if (setters.isObservable(value)) {
setters.useRenderEffect(() => {
setStyleStatic(element, key, value());
}, stack);
} else {
setStyleStatic(element, key, setters.get(value));
}
} else {
setStyleStatic(element, key, setters.get(value));
}
};
const setStylesStatic = (element, object, objectPrev, stack) => {
if (setters.isString(object)) {
element.setAttribute("style", object);
} else {
if (objectPrev) {
if (setters.isString(objectPrev)) {
if (objectPrev) {
element.style.cssText = "";
}
} else {
objectPrev = setters.store.unwrap(objectPrev);
for (const key in objectPrev) {
if (object && key in object) continue;
setStyleStatic(element, key, null);
}
}
}
if (setters.isStore(object)) {
for (const key in object) {
const fn = setters.untrack(() => setters.isFunction(object[key]) ? object[key] : object[setters.SYMBOL_STORE_OBSERVABLE](key));
setStyle(element, key, fn, stack);
}
} else {
for (const key in object) {
setStyle(element, key, object[key], stack);
}
}
}
};
const setStyles = (element, object, stack) => {
if (setters.isFunction(object) || setters.isArray(object)) {
if (setters.isObservable(object)) {
let objectPrev;
setters.useRenderEffect(() => {
const objectNext = resolveStyle(object);
setStylesStatic(element, objectNext, objectPrev, stack);
objectPrev = objectNext;
}, stack);
} else {
let objectPrev;
setters.useRenderEffect(() => {
const objectNext = resolveStyle(object);
setStylesStatic(element, objectNext, objectPrev, stack);
objectPrev = objectNext;
}, stack);
}
} else {
setStylesStatic(element, setters.get(object), null, stack);
}
};
const setTemplateAccessor = async (element, key, value) => {
if (key === "children") {
const placeholder = createText("");
element.insertBefore(placeholder, null);
value(element, "setChildReplacement", void 0, placeholder);
} else if (key === "ref") {
value(element, "setRef");
} else if (key === "style") {
value(element, "setStyles");
} else if (key === "class" || key === "className") {
if (!setters.isSVG(element)) {
element.className = "";
}
value(element, "setClasses");
} else if (key === "dangerouslySetInnerHTML") {
value(element, "setHTML");
} else if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110) {
value(element, "setEvent", key.toLowerCase());
} else if (key.charCodeAt(0) === 117 && key.charCodeAt(3) === 58) {
value(element, "setDirective", key.slice(4));
} else if (key === "innerHTML" || key === "outerHTML" || key === "textContent") ;
else if (key in element && !setters.isSVG(element)) {
value(element, "setProperty", key);
} else {
element.setAttribute(key, "");
value(element, "setAttribute", key);
}
};
const setProp = (element, key, value, stack) => {
if (setters.isTemplateAccessor(value))
setTemplateAccessor(element, key, value);
else if (key === "children")
setChild(element, value, stack);
else if (key === "ref")
setRef(element, value);
else if (key === "style")
setStyles(element, value, stack);
else if (key === "class" || key === "className")
setClasses(element, value, stack);
else if (key === "dangerouslySetInnerHTML")
setHTML(element, value, stack);
else if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110)
setEvent(element, key.toLowerCase(), value);
else if (key.charCodeAt(0) === 117 && key.charCodeAt(3) === 58)
setDirective(element, key.slice(4), value);
else if (key === "innerHTML" || key === "outerHTML" || key === "textContent") ;
else {
setProperty(element, key, value, stack);
setAttribute(element, key, value, stack);
}
};
const setProps = (element, object, stack) => {
const { children, ...pp } = object;
setProp(element, "children", children, stack);
for (const key in pp)
setProp(element, key, object[key], stack);
};
const IsSvgSymbol = Symbol("isSvg");
IgnoreSymbols[IsSvgSymbol] = IsSvgSymbol;
const createElement = (component, _props, ..._children) => {
const children = _children.length > 1 ? _children : _children.length > 0 ? _children[0] : void 0;
const hasChildren = !setters.isVoidChild(children);
if (hasChildren && setters.isObject(_props) && "children" in _props) {
throw new Error('Providing "children" both as a prop and as rest arguments is forbidden');
}
if (setters.isFunction(component)) {
const props = hasChildren ? { ..._props, children } : _props;
return runtime.wrapElement(() => {
return setters.untrack(() => component.call(component, props));
});
} else if (setters.isString(component)) {
const isSVG = setters.isSVGElement(component);
const createNode = isSVG ? createSVGNode : createHTMLNode;
return runtime.wrapElement(() => {
const child = createNode(component);
if (isSVG) {
child["isSVG"] = true;
child[IsSvgSymbol] = true;
}
const stack = new Error();
setters.untrack(() => {
if (_props) {
setProps(child, _props, stack);
}
if (hasChildren) {
setChild(
child,
children,
/* FragmentUtils.make(), */
stack
);
}
});
return child;
});
} else if (setters.isNode(component)) {
return runtime.wrapElement(() => component);
} else {
throw new Error("Invalid component");
}
};
const Dynamic = ({
component,
props
/* , children */
}) => {
if (setters.isFunction(component) || setters.isFunction(props)) {
return render_to_string.memo(() => {
return render_to_string.resolve(createElement(
setters.get(component, false),
setters.get(props)
/* children */
));
});
} else {
return createElement(
component,
props
/* children */
);
}
};
const render = (child, parent) => {
if (!parent || !(parent instanceof HTMLElement)) throw new Error("Invalid parent node");
parent.textContent = "";
return root.root((stack, dispose) => {
setChild(parent, child, stack);
return () => {
dispose(stack);
parent.textContent = "";
};
});
};
const Portal = ({ when = true, mount, wrapper, children }) => {
const portal = setters.get(wrapper) || createHTMLNode("div");
if (!(portal instanceof HTMLElement)) throw new Error("Invalid wrapper node");
const condition = render_to_string.boolean(when);
const stack = new Error();
setters.useRenderEffect(() => {
if (!setters.get(condition)) return;
const parent = setters.get(mount) || document.body;
if (!(parent instanceof Element)) throw new Error("Invalid mount node");
parent.insertBefore(portal, null);
return () => {
parent.removeChild(portal);
};
}, stack);
setters.useRenderEffect(() => {
if (!setters.get(condition)) return;
return render(children, portal);
}, stack);
return setters.assign(() => setters.get(condition) || children, { metadata: { portal } });
};
function jsx(component, props, ...children) {
if (typeof children === "string")
return runtime.wrapCloneElement(createElement(component, props ?? {}, children), component, props);
if (!props) props = {};
if (typeof children === "string")
Object.assign(props, { children });
return runtime.wrapCloneElement(createElement(component, props, props == null ? void 0 : props.key), component, props);
}
const jsxDEV = (component, props, key, isStatic, source, self2) => {
if (key)
Object.assign(props, { key });
return runtime.wrapCloneElement(createElement(component, props), component, props);
};
const cloneElement = (element, props, ...children) => {
if (setters.isPrimitive(element))
return element;
else if (setters.isFunction(element)) {
if (!element[setters.SYMBOL_CLONE])
throw new Error("target is not cloneable, it is not created by jsx.createElement");
const { Component, props: oldProps } = element[setters.SYMBOL_CLONE];
const newProps = { ...oldProps, ...props };
if (children.length > 0)
Object.assign(props, { children });
return runtime.wrapCloneElement(createElement(Component, newProps), Component, newProps);
} else if (setters.isArray(element))
return element.map((e) => cloneElement(e, props));
else if (element.cloneNode)
return element.cloneNode();
throw new Error("Unknown element");
};
function h$1(component, props, ...children) {
if (children.length || setters.isObject(props) && !setters.isArray(props)) {
if (!props) props = { children };
else props = { ...props, children };
return createElement(component, props);
} else {
return createElement(component, null, props);
}
}
const registry = {};
const h = (type, props, ...children) => createElement(registry[type] || type, props, ...children);
const register = (components) => void setters.assign(registry, components);
const html = setters.assign(render_to_string.htm.bind(h), { register });
const lazy = (fetcher) => {
const fetcherOnce = setters.once(fetcher);
const component = (props) => {
const resource = render_to_string.useResource(fetcherOnce);
return render_to_string.memo(() => {
return render_to_string.useResolved(resource, ({ pending, error, value }) => {
if (pending) return;
if (error) throw error;
const component2 = "default" in value ? value.default : value;
return render_to_string.resolve(createElement(component2, props));
});
});
};
component.preload = () => {
return new Promise((resolve2, reject) => {
const resource = render_to_string.useResource(fetcherOnce);
render_to_string.useResolved(resource, ({ pending, error }) => {
if (pending) return;
if (error) return reject(error);
return resolve2();
});
});
};
return component;
};
const template = (fn) => {
const safePropertyRe = /^[a-z0-9-_]+$/i;
const checkValidProperty = (property) => {
if (setters.isString(property) && safePropertyRe.test(property)) return true;
throw new Error(`Invalid property, only alphanumeric properties are allowed inside templates, received: "${property}"`);
};
const makeAccessor = (actionsWithNodes) => {
return new Proxy({}, {
get(target, prop) {
checkValidProperty(prop);
const accessor = (node, method, key, targetNode) => {
if (key) checkValidProperty(key);
actionsWithNodes.push([node, method, prop, key, targetNode]);
};
const metadata = { [setters.SYMBOL_TEMPLATE_ACCESSOR]: true };
return setters.assign(accessor, metadata);
}
});
};
const makeActionsWithNodesAndTemplate = () => {
const actionsWithNodes = [];
const accessor = makeAccessor(actionsWithNodes);
const component = fn(accessor);
if (setters.isFunction(component)) {
const root2 = component();
if (root2 instanceof Element) {
return { actionsWithNodes, root: root2 };
}
}
throw new Error("Invalid template, it must return a function that returns an Element");
};
const makeActionsWithPaths = (actionsWithNodes) => {
const actionsWithPaths = [];
for (let i = 0, l = actionsWithNodes.length; i < l; i++) {
const [node, method, prop, key, targetNode] = actionsWithNodes[i];
const nodePath = makeNodePath(node);
const targetNodePath = targetNode ? makeNodePath(targetNode) : void 0;
actionsWithPaths.push([nodePath, method, prop, key, targetNodePath]);
}
return actionsWithPaths;
};
const makeNodePath = /* @__PURE__ */ (() => {
let prevNode = null;
let prevPath;
return (node) => {
if (node === prevNode) return prevPath;
const path = [];
let child = node;
let parent = child.parentNode;
while (parent) {
const index = !child.previousSibling ? 0 : !child.nextSibling ? -0 : setters.indexOf(parent.childNodes, child);
path.push(index);
child = parent;
parent = parent.parentNode;
}
prevNode = node;
prevPath = path;
return path;
};
})();
const makeNodePathProperties = (path) => {
const properties = ["root"];
const parts = path.slice().reverse();
for (let i = 0, l = parts.length; i < l; i++) {
const part = parts[i];
if (Object.is(0, part)) {
properties.push("firstChild");
} else if (Object.is(-0, part)) {
properties.push("lastChild");
} else {
properties.push("firstChild");
for (let nsi = 0; nsi < part; nsi++) {
properties.push("nextSibling");
}
}
}
return properties;
};
const makeReviverPaths = (actionsWithPaths) => {
const paths = [];
for (let i = 0, l = actionsWithPaths.length; i < l; i++) {
const action = actionsWithPaths[i];
const nodePath = action[0];
const targetNodePath = action[4];
paths.push(nodePath);
if (targetNodePath) {
paths.push(targetNodePath);
}
}
return paths;
};
const makeReviverVariablesData = (paths, properties) => {
const data = new Array(paths.length);
for (let i = 0, l = paths.length; i < l; i++) {
data[i] = {
path: paths[i],
properties: properties[i]
};
}
return data;
};
const makeReviverVariables = (actionsWithPaths) => {
const paths = makeReviverPaths(actionsWithPaths);
const properties = paths.map(makeNodePathProperties);
const data = makeReviverVariablesData(paths, properties);
const assignments = [];
const map = /* @__PURE__ */ new Map();
let variableId = 0;
while (true) {
const datum = data.find((datum2) => datum2.properties.length > 1);
if (!datum) break;
const [current, next] = datum.properties;
const variable = `$${variableId++}`;
const assignment = `const ${variable} = ${current}.${next};`;
assignments.push(assignment);
for (let i = 0, l = data.length; i < l; i++) {
const datum2 = data[i];
const [otherCurrent, otherNext] = datum2.properties;
if (otherCurrent !== current || otherNext !== next) continue;
datum2.properties[0] = variable;
datum2.properties.splice(1, 1);
}
}
for (let i = 0, l = data.length; i < l; i++) {
const datum = data[i];
map.set(datum.path, datum.properties[0]);
}
return { assignments, map };
};
const makeReviverActions = (actionsWithPaths, variables) => {
const actions = [];
for (let i = 0, l = actionsWithPaths.length; i < l; i++) {
const [nodePath, method, prop, key, targetNodePath] = actionsWithPaths[i];
if (targetNodePath) {
actions.push(`this.${method} ( props["${prop}"], ${variables.get(targetNodePath)} );`);
} else if (key) {
actions.push(`this.${method} ( ${variables.get(nodePath)}, "${key}", props["${prop}"] );`);
} else {
actions.push(`this.${method} ( ${variables.get(nodePath)}, props["${prop}"] );`);
}
}
return actions;
};
const makeReviver = (actionsWithPaths) => {
const { assignments, map } = makeReviverVariables(actionsWithPaths);
const actions = makeReviverActions(actionsWithPaths, map);
const fn2 = new Function("root", "props", `${assignments.join("")}${actions.join("")}return root;`);
const apis = { setAttribute, setClasses, setEvent, setHTML, setProperty, setRef, setStyles };
const reviver = fn2.bind(apis);
return reviver;
};
const makeComponent = () => {
const { actionsWithNodes, root: root2 } = makeActionsWithNodesAndTemplate();
const actionsWithPaths = makeActionsWithPaths(actionsWithNodes);
const reviver = makeReviver(actionsWithPaths);
return (props) => {
const clone = root2.cloneNode(true);
return runtime.wrapElement(reviver.bind(void 0, clone, props));
};
};
return makeComponent();
};
exports.$$ = setters.get;
exports.CONTEXTS_DATA = setters.CONTEXTS_DATA;
exports.DIRECTIVES = setters.DIRECTIVES;
exports.SYMBOLS_DIRECTIVES = setters.SYMBOLS_DIRECTIVES;
exports.SYMBOL_CLONE = setters.SYMBOL_CLONE;
exports.SYMBOL_DEFAULT = setters.SYMBOL_DEFAULT;
exports.SYMBOL_JSX = setters.SYMBOL_JSX;
exports.SYMBOL_OBSERVABLE = setters.SYMBOL_OBSERVABLE;
exports.SYMBOL_OBSERVABLE_FROZEN = setters.SYMBOL_OBSERVABLE_FROZEN;
exports.SYMBOL_OBSERVABLE_READABLE = setters.SYMBOL_OBSERVABLE_READABLE;
exports.SYMBOL_OBSERVABLE_WRITABLE = setters.SYMBOL_OBSERVABLE_WRITABLE;
exports.SYMBOL_SUSPENSE = setters.SYMBOL_SUSPENSE$1;
exports.SYMBOL_SUSPENSE_COLLECTOR = setters.SYMBOL_SUSPENSE_COLLECTOR;
exports.SYMBOL_TEMPLATE_ACCESSOR = setters.SYMBOL_TEMPLATE_ACCESSOR;
exports.SYMBOL_UNCACHED = setters.S