sibujs 1.0.0-beta.1

package/dist/chunk-566Z7HXB.js

@@ -0,0 +1,737 @@
+// src/utils/sanitize.ts
+function sanitize(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  const trimmed = url.replace(/[\x00-\x1f]+/g, "").trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:")) {
+    return "";
+  }
+  return trimmed;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+function sanitizeAttribute(attr, value) {
+  if (isUrlAttribute(attr)) {
+    return sanitizeUrl(value);
+  }
+  return sanitize(value);
+}
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var subscriberDependencies = /* @__PURE__ */ new WeakMap();
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function recordDependency(signal) {
+  if (!currentSubscriber) return;
+  let deps = subscriberDependencies.get(currentSubscriber);
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    subscriberDependencies.set(currentSubscriber, deps);
+  }
+  if (!deps.has(signal)) {
+    deps.add(signal);
+    let subs = signalSubscribers.get(signal);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal, subs);
+    }
+    subs.add(currentSubscriber);
+  }
+}
+function queueSignalNotification(signal) {
+  const subs = signalSubscribers.get(signal);
+  if (!subs) return;
+  for (const sub2 of subs) {
+    if (!pendingSet.has(sub2)) {
+      pendingSet.add(sub2);
+      pendingQueue.push(sub2);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i2 = 0;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function notifySubscribers(signal) {
+  const subs = signalSubscribers.get(signal);
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub2 of subs) {
+      if (!pendingSet.has(sub2)) {
+        pendingSet.add(sub2);
+        pendingQueue.push(sub2);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub2 of subs) {
+      pendingQueue[directCount++] = sub2;
+    }
+    for (let i3 = 0; i3 < directCount; i3++) {
+      pendingQueue[i3]();
+    }
+    let i2 = directCount;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriberDependencies.get(subscriber);
+  if (!deps) return;
+  for (const signal of deps) {
+    const subs = signalSubscribers.get(signal);
+    subs?.delete(subscriber);
+  }
+  deps.clear();
+  subscriberDependencies.delete(subscriber);
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch {
+      return;
+    }
+    const str = sanitizeAttribute(attr, String(value));
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, str);
+    }
+  }
+  const teardown = track(commit);
+  return teardown;
+}
+function bindDynamic(el, nameGetter, valueGetter) {
+  let prevName = null;
+  function commit() {
+    let name;
+    try {
+      name = typeof nameGetter === "function" ? nameGetter() : nameGetter;
+    } catch {
+      return;
+    }
+    let value;
+    try {
+      value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
+    } catch {
+      return;
+    }
+    if (name.toLowerCase().startsWith("on")) return;
+    if (prevName !== null && prevName !== name) {
+      el.removeAttribute(prevName);
+    }
+    const str = sanitizeAttribute(name, String(value));
+    if ((name === "value" || name === "checked") && name in el) {
+      el[name] = name === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(name, str);
+    }
+    prevName = name;
+  }
+  const teardown = track(commit);
+  return () => {
+    teardown();
+    if (prevName !== null) {
+      el.removeAttribute(prevName);
+    }
+  };
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+}
+function dispose(node) {
+  const children = node.childNodes;
+  for (const child of children) {
+    dispose(child);
+  }
+  const disposers = elementDisposers.get(node);
+  if (disposers) {
+    for (const d of disposers) d();
+    elementDisposers.delete(node);
+  }
+}
+
+// src/reactivity/bindChildNode.ts
+function bindChildNode(placeholder, getter) {
+  let lastNodes = [];
+  function commit() {
+    let result;
+    try {
+      result = getter();
+    } catch {
+      return;
+    }
+    for (const node of lastNodes) {
+      node.parentNode?.removeChild(node);
+    }
+    lastNodes = [];
+    if (result == null) return;
+    const parent = placeholder.parentNode;
+    const anchor = placeholder.nextSibling;
+    const newNodes = [];
+    const insertItem = (item) => {
+      const node = item instanceof Node ? item : document.createTextNode(String(item));
+      parent.insertBefore(node, anchor);
+      newNodes.push(node);
+    };
+    if (Array.isArray(result)) {
+      for (const item of result) insertItem(item);
+    } else {
+      insertItem(result);
+    }
+    lastNodes = newNodes;
+  }
+  return track(commit);
+}
+
+// src/core/rendering/tagFactory.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var kebabCache = /* @__PURE__ */ new Map();
+function toKebab(prop) {
+  let cached = kebabCache.get(prop);
+  if (cached !== void 0) return cached;
+  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+  kebabCache.set(prop, cached);
+  return cached;
+}
+function applyStyle(el, style2) {
+  if (!style2) return;
+  if (typeof style2 === "function") {
+    const teardown = track(() => {
+      el.setAttribute("style", style2());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof style2 === "string") {
+    el.setAttribute("style", style2);
+    return;
+  }
+  const htmlEl = el;
+  for (const prop in style2) {
+    const val = style2[prop];
+    const name = toKebab(prop);
+    if (typeof val === "function") {
+      const getter = val;
+      const teardown = track(() => {
+        htmlEl.style.setProperty(name, String(getter()));
+      });
+      registerDisposer(el, teardown);
+    } else {
+      htmlEl.style.setProperty(name, String(val));
+    }
+  }
+}
+function applyClass(el, cls) {
+  if (cls == null) return;
+  if (typeof cls === "string") {
+    el.setAttribute("class", cls);
+    return;
+  }
+  if (typeof cls === "function") {
+    const getter = cls;
+    const teardown = track(() => {
+      el.setAttribute("class", getter());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof cls === "object") {
+    const obj = cls;
+    let hasReactive = false;
+    for (const name in obj) {
+      if (typeof obj[name] === "function") {
+        hasReactive = true;
+        break;
+      }
+    }
+    if (hasReactive) {
+      const update = () => {
+        let result = "";
+        for (const name in obj) {
+          const val = obj[name];
+          const active = typeof val === "function" ? val() : val;
+          if (active) result = result ? `${result} ${name}` : name;
+        }
+        el.setAttribute("class", result);
+      };
+      const teardown = track(update);
+      registerDisposer(el, teardown);
+    } else {
+      let result = "";
+      for (const name in obj) {
+        if (obj[name]) result = result ? `${result} ${name}` : name;
+      }
+      el.setAttribute("class", result);
+    }
+  }
+}
+function renderChild(parent, child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (typeof child === "function") {
+    const placeholder = document.createComment("bind:child");
+    queueMicrotask(() => {
+      const teardown = bindChildNode(placeholder, child);
+      registerDisposer(parent, teardown);
+    });
+    return placeholder;
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function appendChildren(el, nodes) {
+  if (Array.isArray(nodes)) {
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      const c = nodes[i2];
+      if (Array.isArray(c)) {
+        for (let j = 0; j < c.length; j++) {
+          el.appendChild(renderChild(el, c[j]));
+        }
+      } else {
+        el.appendChild(renderChild(el, c));
+      }
+    }
+  } else {
+    el.appendChild(renderChild(el, nodes));
+  }
+}
+var tagFactory = (tag, ns) => (props = {}) => {
+  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+  for (const key in props) {
+    const value = props[key];
+    if (value == null) continue;
+    switch (key) {
+      case "id":
+        el.id = value;
+        break;
+      case "class":
+        applyClass(el, value);
+        break;
+      case "style":
+        applyStyle(el, value);
+        break;
+      case "ref":
+        if (value && typeof value === "object" && "current" in value) {
+          value.current = el;
+        }
+        break;
+      case "on": {
+        const handlers = value;
+        for (const ev in handlers) {
+          el.addEventListener(ev, handlers[ev]);
+        }
+        break;
+      }
+      case "nodes":
+        appendChildren(el, value);
+        break;
+      default:
+        if (typeof value === "function") {
+          const teardown = bindAttribute(el, key, value);
+          registerDisposer(el, teardown);
+        } else if (typeof value === "boolean") {
+          if (value) el.setAttribute(key, "");
+          else el.removeAttribute(key);
+        } else {
+          el.setAttribute(key, String(value));
+        }
+    }
+  }
+  return el;
+};
+
+// src/core/rendering/html.ts
+var html = tagFactory("html");
+var head = tagFactory("head");
+var body = tagFactory("body");
+var title = tagFactory("title");
+var div = tagFactory("div");
+var span = tagFactory("span");
+var section = tagFactory("section");
+var article = tagFactory("article");
+var header = tagFactory("header");
+var footer = tagFactory("footer");
+var nav = tagFactory("nav");
+var main = tagFactory("main");
+var aside = tagFactory("aside");
+var address = tagFactory("address");
+var p = tagFactory("p");
+var h1 = tagFactory("h1");
+var h2 = tagFactory("h2");
+var h3 = tagFactory("h3");
+var h4 = tagFactory("h4");
+var h5 = tagFactory("h5");
+var h6 = tagFactory("h6");
+var blockquote = tagFactory("blockquote");
+var dd = tagFactory("dd");
+var dl = tagFactory("dl");
+var dt = tagFactory("dt");
+var figcaption = tagFactory("figcaption");
+var figure = tagFactory("figure");
+var hr = tagFactory("hr");
+var li = tagFactory("li");
+var ol = tagFactory("ol");
+var ul = tagFactory("ul");
+var pre = tagFactory("pre");
+var a = tagFactory("a");
+var abbr = tagFactory("abbr");
+var b = tagFactory("b");
+var bdi = tagFactory("bdi");
+var bdo = tagFactory("bdo");
+var br = tagFactory("br");
+var cite = tagFactory("cite");
+var code = tagFactory("code");
+var data = tagFactory("data");
+var dfn = tagFactory("dfn");
+var em = tagFactory("em");
+var i = tagFactory("i");
+var kbd = tagFactory("kbd");
+var mark = tagFactory("mark");
+var q = tagFactory("q");
+var rp = tagFactory("rp");
+var rt = tagFactory("rt");
+var ruby = tagFactory("ruby");
+var s = tagFactory("s");
+var samp = tagFactory("samp");
+var small = tagFactory("small");
+var strong = tagFactory("strong");
+var sub = tagFactory("sub");
+var sup = tagFactory("sup");
+var time = tagFactory("time");
+var u = tagFactory("u");
+var var_ = tagFactory("var");
+var area = tagFactory("area");
+var audio = tagFactory("audio");
+var img = tagFactory("img");
+var map = tagFactory("map");
+var track2 = tagFactory("track");
+var video = tagFactory("video");
+var embed = tagFactory("embed");
+var iframe = tagFactory("iframe");
+var object = tagFactory("object");
+var param = tagFactory("param");
+var picture = tagFactory("picture");
+var portal = tagFactory("portal");
+var source = tagFactory("source");
+var svg = tagFactory("svg", SVG_NS);
+var math = tagFactory("math");
+var canvas = tagFactory("canvas");
+var noscript = tagFactory("noscript");
+var script = tagFactory("script");
+var del = tagFactory("del");
+var ins = tagFactory("ins");
+var caption = tagFactory("caption");
+var col = tagFactory("col");
+var colgroup = tagFactory("colgroup");
+var table = tagFactory("table");
+var tbody = tagFactory("tbody");
+var td = tagFactory("td");
+var tfoot = tagFactory("tfoot");
+var th = tagFactory("th");
+var thead = tagFactory("thead");
+var tr = tagFactory("tr");
+var button = tagFactory("button");
+var datalist = tagFactory("datalist");
+var fieldset = tagFactory("fieldset");
+var form = tagFactory("form");
+var input = tagFactory("input");
+var label = tagFactory("label");
+var legend = tagFactory("legend");
+var meter = tagFactory("meter");
+var optgroup = tagFactory("optgroup");
+var option = tagFactory("option");
+var output = tagFactory("output");
+var progress = tagFactory("progress");
+var select = tagFactory("select");
+var textarea = tagFactory("textarea");
+var details = tagFactory("details");
+var dialog = tagFactory("dialog");
+var menu = tagFactory("menu");
+var summary = tagFactory("summary");
+var slot = tagFactory("slot");
+var template = tagFactory("template");
+var base = tagFactory("base");
+var link = tagFactory("link");
+var meta = tagFactory("meta");
+var style = tagFactory("style");
+var circle = tagFactory("circle", SVG_NS);
+var ellipse = tagFactory("ellipse", SVG_NS);
+var g = tagFactory("g", SVG_NS);
+var line = tagFactory("line", SVG_NS);
+var path = tagFactory("path", SVG_NS);
+var polygon = tagFactory("polygon", SVG_NS);
+var polyline = tagFactory("polyline", SVG_NS);
+var rect = tagFactory("rect", SVG_NS);
+var text = tagFactory("text", SVG_NS);
+var tspan = tagFactory("tspan", SVG_NS);
+var defs = tagFactory("defs", SVG_NS);
+var clipPath = tagFactory("clipPath", SVG_NS);
+var mask = tagFactory("mask", SVG_NS);
+var pattern = tagFactory("pattern", SVG_NS);
+var linearGradient = tagFactory("linearGradient", SVG_NS);
+var radialGradient = tagFactory("radialGradient", SVG_NS);
+var stop = tagFactory("stop", SVG_NS);
+var use = tagFactory("use", SVG_NS);
+var symbol = tagFactory("symbol", SVG_NS);
+var marker = tagFactory("marker", SVG_NS);
+var center = tagFactory("center");
+var font = tagFactory("font");
+var marquee = tagFactory("marquee");
+var customElement = (tagName) => tagFactory(tagName);
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal);
+  return true;
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal of signals) {
+    queueSignalNotification(signal);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/hooks/useState.ts
+function useState(initial) {
+  const state = { value: initial };
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    state.value = newValue;
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  return [get, set];
+}
+
+export {
+  track,
+  recordDependency,
+  notifySubscribers,
+  bindAttribute,
+  bindDynamic,
+  registerDisposer,
+  dispose,
+  SVG_NS,
+  tagFactory,
+  html,
+  head,
+  body,
+  title,
+  div,
+  span,
+  section,
+  article,
+  header,
+  footer,
+  nav,
+  main,
+  aside,
+  address,
+  p,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  blockquote,
+  dd,
+  dl,
+  dt,
+  figcaption,
+  figure,
+  hr,
+  li,
+  ol,
+  ul,
+  pre,
+  a,
+  abbr,
+  b,
+  bdi,
+  bdo,
+  br,
+  cite,
+  code,
+  data,
+  dfn,
+  em,
+  i,
+  kbd,
+  mark,
+  q,
+  rp,
+  rt,
+  ruby,
+  s,
+  samp,
+  small,
+  strong,
+  sub,
+  sup,
+  time,
+  u,
+  var_,
+  area,
+  audio,
+  img,
+  map,
+  track2,
+  video,
+  embed,
+  iframe,
+  object,
+  param,
+  picture,
+  portal,
+  source,
+  svg,
+  math,
+  canvas,
+  noscript,
+  script,
+  del,
+  ins,
+  caption,
+  col,
+  colgroup,
+  table,
+  tbody,
+  td,
+  tfoot,
+  th,
+  thead,
+  tr,
+  button,
+  datalist,
+  fieldset,
+  form,
+  input,
+  label,
+  legend,
+  meter,
+  optgroup,
+  option,
+  output,
+  progress,
+  select,
+  textarea,
+  details,
+  dialog,
+  menu,
+  summary,
+  slot,
+  template,
+  base,
+  link,
+  meta,
+  style,
+  circle,
+  ellipse,
+  g,
+  line,
+  path,
+  polygon,
+  polyline,
+  rect,
+  text,
+  tspan,
+  defs,
+  clipPath,
+  mask,
+  pattern,
+  linearGradient,
+  radialGradient,
+  stop,
+  use,
+  symbol,
+  marker,
+  center,
+  font,
+  marquee,
+  customElement,
+  batch,
+  enqueueBatchedSignal,
+  isBatching,
+  useState
+};