@cossackframework/renderer 0.0.1

package/dist/children.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/component.d.ts

@@ -0,0 +1,9 @@
+import { CossackElement } from './cossack-element';
+
+export interface ComponentResult {
+    _type: 'COMPONENT';
+    clazz: new () => CossackElement;
+    props: Record<string, unknown>;
+    children: unknown;
+}
+export declare const isComponentResult: (value: unknown) => value is ComponentResult;

package/dist/context.d.ts

@@ -0,0 +1,5 @@
+export interface Context<T> {
+    id: string;
+    defaultValue?: T;
+}
+export declare function createContext<T>(defaultValue?: T): Context<T>;

package/dist/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cossack-element.d.ts

@@ -0,0 +1,69 @@
+import { TemplateResult } from './cossack-html';
+import { Context } from './context';
+
+export type PropertyDeclaration = {
+    type?: unknown;
+    reflect?: boolean;
+    state?: boolean;
+};
+export interface PropertyDeclarations {
+    [key: string]: PropertyDeclaration;
+}
+export type PropertyValues = Map<string | number | symbol, unknown>;
+export interface ReactiveController {
+    hostConnected?(): void;
+    hostDisconnected?(): void;
+    hostUpdate?(): void;
+    hostUpdated?(): void;
+}
+export interface ReactiveControllerHost {
+    requestUpdate(): void;
+    addController(controller: ReactiveController): void;
+    removeController(controller: ReactiveController): void;
+    readonly updateComplete: Promise<boolean>;
+}
+export declare const instanceStack: CossackElement[];
+export declare const pushCurrentInstance: (instance: CossackElement) => number;
+export declare const popCurrentInstance: () => CossackElement | undefined;
+export declare class CossackElement implements ReactiveControllerHost {
+    static properties: PropertyDeclarations;
+    static readonly _isCossackElement = true;
+    children: unknown;
+    props: Record<string, unknown>;
+    __parent: CossackElement | null;
+    _id: string;
+    _childCounter: number;
+    private __providedContexts;
+    private __properties;
+    private __updatePromise;
+    private __changedProperties;
+    private __renderListeners;
+    private __controllers;
+    private __hasConnected;
+    private __eventListeners;
+    constructor();
+    static get currentRenderingInstance(): CossackElement | null;
+    resetRenderState(): void;
+    addController(controller: ReactiveController): void;
+    removeController(controller: ReactiveController): void;
+    get updateComplete(): Promise<boolean>;
+    private initialize;
+    private createProperty;
+    provide<T>(context: Context<T>, value: T): void;
+    consume<T>(context: Context<T>): T | undefined;
+    requestUpdate(name?: string, oldValue?: unknown): Promise<boolean>;
+    protected performUpdate(): Promise<boolean>;
+    private __notifyListeners;
+    addRenderListener(listener: (template: TemplateResult | unknown | null) => void): void;
+    removeRenderListener(listener: (template: TemplateResult | unknown | null) => void): void;
+    mount(container: HTMLElement): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, _options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, _options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    shouldUpdate(_changedProperties: PropertyValues): boolean;
+    willUpdate(_changedProperties: PropertyValues): void;
+    render(): TemplateResult | null;
+    updated(_changedProperties: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/dist/cossack-html.d.ts

@@ -0,0 +1,21 @@
+import { CossackElement } from './cossack-element';
+
+export declare class TemplateResult {
+    readonly strings: TemplateStringsArray;
+    readonly values: unknown[];
+    readonly _cossack_template_result = true;
+    constructor(strings: TemplateStringsArray, values: unknown[]);
+}
+export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+export declare const svg: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult;
+export declare const component: <T extends CossackElement>(clazz: new () => T, props?: Record<string, unknown>, children?: unknown) => TemplateResult;
+export declare const isTemplateResult: (value: unknown) => value is TemplateResult;
+export declare class UnsafeHTMLResult {
+    readonly value: string;
+    constructor(value: string);
+}
+export declare const unsafeHTML: (value: string) => UnsafeHTMLResult;
+export declare const isUnsafeHTML: (value: unknown) => value is UnsafeHTMLResult;
+export declare const escapeHtml: (unsafe: unknown) => string;
+export declare const renderToString: (result: TemplateResult) => string;
+export declare const render: (result: TemplateResult, container: Node) => void;

package/dist/cossack-html.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cossack-syntax.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/directives.d.ts

@@ -0,0 +1,31 @@
+export declare class LiveResult {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare class RepeatResult {
+    readonly items: unknown[];
+    readonly keyFn: (item: any, index: number) => unknown;
+    readonly templateFn: (item: any, index: number) => unknown;
+    constructor(items: unknown[], keyFn: (item: any, index: number) => unknown, templateFn: (item: any, index: number) => unknown);
+}
+/**
+ * Checks against the DOM value instead of the previous rendered value.
+ * Usage: <input .value=${live(x)}>
+ */
+export declare const live: (value: unknown) => LiveResult;
+/**
+ * Repeats a template for each item in an array, using a key to maintain state.
+ * Usage: repeat(items, (item) => item.id, (item) => html`...`)
+ */
+export declare const repeat: (items: unknown[], keyFnOrTemplate: (item: any, index: number) => unknown, template?: (item: any, index: number) => unknown) => RepeatResult;
+/**
+ * Generates a class string from an object.
+ * Usage: class="${classMap({ active: isActive })}"
+ */
+export declare const classMap: (classInfo: Record<string, string | boolean | number>) => string;
+/**
+ * Generates a style string from an object.
+ * Usage: style="${styleMap({ color: 'red' })}"
+ */
+export declare const styleMap: (styleInfo: Record<string, string | undefined | null>) => string;
+export type RefCallback = (el: Element | undefined) => void;

package/dist/directives.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cossack-html';
+export * from './cossack-element';
+export * from './component';
+export * from './context';
+export * from './directives';

package/dist/index.js

@@ -0,0 +1,32 @@
+import { C as n, L as r, R as l, T as p, U as o, k as u, c, e as i, h as m, d as R, g as T, i as f, a as C, l as M, f as d, p as L, b as g, r as h, j as H, m as k, s as v, u as x } from "./server-BEO1YttH.js";
+function e(s) {
+  return {
+    id: Math.random().toString(36).slice(2),
+    defaultValue: s
+  };
+}
+export {
+  n as CossackElement,
+  r as LiveResult,
+  l as RepeatResult,
+  p as TemplateResult,
+  o as UnsafeHTMLResult,
+  u as classMap,
+  c as component,
+  e as createContext,
+  i as escapeHtml,
+  m as html,
+  R as instanceStack,
+  T as isComponentResult,
+  f as isTemplateResult,
+  C as isUnsafeHTML,
+  M as live,
+  d as popCurrentInstance,
+  L as pushCurrentInstance,
+  g as render,
+  h as renderToString,
+  H as repeat,
+  k as styleMap,
+  v as svg,
+  x as unsafeHTML
+};

package/dist/lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server-BEO1YttH.js

@@ -0,0 +1,491 @@
+var F = Object.defineProperty;
+var z = (n, e, s) => e in n ? F(n, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : n[e] = s;
+var h = (n, e, s) => z(n, typeof e != "symbol" ? e + "" : e, s);
+const L = (n) => typeof n == "object" && n !== null && n._type === "COMPONENT", g = [], k = (n) => g.push(n), x = () => g.pop();
+class T {
+  constructor() {
+    // Holds content projected from the parent
+    h(this, "children", null);
+    h(this, "props", {});
+    // Context Support
+    h(this, "__parent", null);
+    h(this, "_id", "");
+    h(this, "_childCounter", 0);
+    h(this, "__providedContexts", /* @__PURE__ */ new Map());
+    h(this, "__properties", /* @__PURE__ */ new Map());
+    h(this, "__updatePromise", null);
+    h(this, "__changedProperties", /* @__PURE__ */ new Map());
+    h(this, "__renderListeners", /* @__PURE__ */ new Set());
+    // Controllers
+    h(this, "__controllers", /* @__PURE__ */ new Set());
+    h(this, "__hasConnected", !1);
+    h(this, "__eventListeners", /* @__PURE__ */ new Map());
+    this.initialize();
+  }
+  // --- Static Stack Access for cossack-html ---
+  static get currentRenderingInstance() {
+    return g.length > 0 ? g[g.length - 1] : null;
+  }
+  resetRenderState() {
+    this._childCounter = 0;
+  }
+  // --- Controller API ---
+  addController(e) {
+    this.__controllers.add(e), this.__hasConnected && e.hostConnected && e.hostConnected();
+  }
+  removeController(e) {
+    this.__controllers.delete(e);
+  }
+  get updateComplete() {
+    return this.__updatePromise || Promise.resolve(!0);
+  }
+  initialize() {
+    const s = this.constructor.properties;
+    if (s)
+      for (const [t, i] of Object.entries(s))
+        this.createProperty(t, i);
+  }
+  createProperty(e, s) {
+    Object.prototype.hasOwnProperty.call(this, e) && this.__properties.set(e, this[e]), Object.defineProperty(this, e, {
+      get() {
+        return this.__properties.get(e);
+      },
+      set(t) {
+        const i = this.__properties.get(e);
+        i !== t && (this.__properties.set(e, t), this.requestUpdate(e, i));
+      },
+      configurable: !0,
+      enumerable: !0
+    });
+  }
+  provide(e, s) {
+    this.__providedContexts.set(e, s);
+  }
+  consume(e) {
+    let s = this.__parent;
+    for (; s; ) {
+      if (s.__providedContexts.has(e))
+        return s.__providedContexts.get(e);
+      s = s.__parent;
+    }
+    return e.defaultValue;
+  }
+  requestUpdate(e, s) {
+    return e !== void 0 && (this.__changedProperties.has(e) || this.__changedProperties.set(e, s)), this.__updatePromise || (this.__updatePromise = this.performUpdate()), this.__updatePromise;
+  }
+  async performUpdate() {
+    await Promise.resolve();
+    let e = !1;
+    try {
+      if (e = this.shouldUpdate(this.__changedProperties), e) {
+        this.__controllers.forEach((t) => t.hostUpdate && t.hostUpdate()), this.willUpdate(this.__changedProperties), this.resetRenderState(), k(this);
+        const s = this.render();
+        this.__notifyListeners(s), x(), this.updated(this.__changedProperties), this.__controllers.forEach((t) => t.hostUpdated && t.hostUpdated());
+      }
+    } catch (s) {
+      console.error("Error during update:", s), g[g.length - 1] === this && x();
+    }
+    return this.__changedProperties = /* @__PURE__ */ new Map(), this.__updatePromise = null, e;
+  }
+  __notifyListeners(e) {
+    this.__renderListeners.forEach((s) => s(e));
+  }
+  addRenderListener(e) {
+    this.__renderListeners.add(e);
+  }
+  removeRenderListener(e) {
+    this.__renderListeners.delete(e);
+  }
+  mount(e) {
+    this.addRenderListener((s) => {
+      s && (S(s) ? I(s, e) : I(E`${s}`, e));
+    }), this.requestUpdate();
+  }
+  addEventListener(e, s, t) {
+    s && (this.__eventListeners.has(e) || this.__eventListeners.set(e, /* @__PURE__ */ new Set()), this.__eventListeners.get(e).add(s));
+  }
+  removeEventListener(e, s, t) {
+    if (!s) return;
+    const i = this.__eventListeners.get(e);
+    i && i.delete(s);
+  }
+  dispatchEvent(e) {
+    const s = this.__eventListeners.get(e.type);
+    return s && s.forEach((t) => {
+      typeof t == "function" ? t.call(this, e) : t.handleEvent(e);
+    }), !e.defaultPrevented;
+  }
+  shouldUpdate(e) {
+    return !0;
+  }
+  willUpdate(e) {
+  }
+  render() {
+    return null;
+  }
+  updated(e) {
+  }
+  connectedCallback() {
+    this.__hasConnected = !0, this.__controllers.forEach((e) => e.hostConnected && e.hostConnected());
+  }
+  disconnectedCallback() {
+    this.__hasConnected = !1, this.__controllers.forEach((e) => e.hostDisconnected && e.hostDisconnected());
+  }
+}
+h(T, "properties", {}), h(T, "_isCossackElement", !0);
+class R {
+  constructor(e) {
+    this.value = e;
+  }
+}
+class y {
+  constructor(e, s, t) {
+    this.items = e, this.keyFn = s, this.templateFn = t;
+  }
+}
+const Z = (n) => new R(n), X = (n, e, s) => s === void 0 ? new y(n, (t, i) => i, e) : new y(n, e, s), G = (n) => Object.keys(n).filter((e) => n[e]).join(" "), J = (n) => Object.keys(n).filter((e) => n[e] != null).map((e) => `${e}:${n[e]}`).join(";");
+class B {
+  constructor(e, s) {
+    h(this, "_cossack_template_result", !0);
+    this.strings = e, this.values = s;
+  }
+}
+const E = (n, ...e) => new B(n, e), Q = E, Y = (n, e = {}, s) => E`${{
+  _type: "COMPONENT",
+  clazz: n,
+  props: e,
+  children: s
+}}`, S = (n) => typeof n == "object" && n !== null && n._cossack_template_result === !0;
+class W {
+  constructor(e) {
+    this.value = e;
+  }
+}
+const ee = (n) => new W(n), U = (n) => n instanceof W, H = (n) => String(n).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;"), N = (n) => {
+  if (n == null || n === !1)
+    return "";
+  if (Array.isArray(n))
+    return n.map(N).join("");
+  if (S(n))
+    return A(n);
+  if (n instanceof R)
+    return N(n.value);
+  if (n instanceof y)
+    return n.items.map((e, s) => N(n.templateFn(e, s))).join("");
+  if (L(n)) {
+    const e = new n.clazz();
+    Object.assign(e, n.props), "props" in e && (e.props = n.props), e.children = n.children, e.__parent = T.currentRenderingInstance, e.__parent && (e._id = `${e.__parent._id}:${e.__parent._childCounter++}`), e.connectedCallback(), k(e), e.willUpdate(/* @__PURE__ */ new Map());
+    const s = e.render();
+    let t = "";
+    return s && (S(s) ? t = A(s) : t = A(E`${s}`)), x(), t;
+  }
+  return U(n) ? n.value : typeof n == "function" || typeof n == "object" && n !== null && "value" in n ? "" : H(n);
+}, V = (n) => {
+  let e = "";
+  if (typeof n == "object" && n !== null)
+    for (const [s, t] of Object.entries(n)) {
+      if (s.startsWith("@")) continue;
+      let i = s, r = t;
+      if (s.startsWith("?")) {
+        t && (e += ` ${s.slice(1)}`);
+        continue;
+      }
+      s.startsWith(".") && (i = s.slice(1)), typeof r == "boolean" ? r && (e += ` ${i}`) : typeof r == "function" || r != null && (e += ` ${i}="${H(r)}"`);
+    }
+  return e;
+};
+class D {
+  constructor(e) {
+    h(this, "result", "");
+    h(this, "stringIdx", 0);
+    h(this, "charIdxForNext", 0);
+    this.resultObj = e;
+  }
+  scan() {
+    const { strings: e, values: s } = this.resultObj;
+    for (; this.stringIdx < e.length; ) {
+      const i = e[this.stringIdx].substring(this.charIdxForNext || 0), r = i.match(/(\.\.\.|[.@?]?[a-zA-Z0-9_-]+)=["']?$/);
+      if (this.result += i, this.charIdxForNext = 0, this.stringIdx < e.length - 1) {
+        const a = s[this.stringIdx];
+        if (r) {
+          const c = r[0], d = r[1];
+          this.result = this.result.substring(0, this.result.length - c.length);
+          const p = c.endsWith('"') ? '"' : c.endsWith("'") ? "'" : "";
+          let m = !0;
+          if (d === "..." ? (this.result = this.result.trimEnd(), this.result += V(a)) : d.startsWith("@") ? this.result = this.result.trimEnd() : d.startsWith("?") ? a ? (this.result = this.result.trimEnd(), this.result += ` ${d.slice(1)}`) : this.result = this.result.trimEnd() : d.startsWith(".") ? a != null && a !== !1 ? (this.result = this.result.trimEnd(), this.result += ` ${d.slice(1)}="${N(a)}"`) : this.result = this.result.trimEnd() : (this.result += c, this.result += N(a), m = !1), p && m) {
+            const f = e[this.stringIdx + 1];
+            f && f.startsWith(p) && (this.charIdxForNext = 1);
+          }
+        } else
+          this.result += N(a);
+      }
+      this.stringIdx++;
+    }
+    return this.result;
+  }
+}
+const A = (n) => new D(n).scan();
+class $ {
+  constructor(e, s) {
+    h(this, "componentInstance", null);
+    h(this, "renderListener", null);
+    h(this, "_childParts", []);
+    h(this, "_partKeys", []);
+    // Cache for nested template result updates
+    h(this, "_cachedTemplateStrings", null);
+    h(this, "_cachedParts", null);
+    this.startNode = e, this.endNode = s;
+  }
+  update(e) {
+    this.componentInstance && (!L(e) || e.clazz !== this.componentInstance.constructor) && this.disposeComponent(), !(e instanceof y) && !Array.isArray(e) && this._childParts.length > 0 && this.clearChildParts(), L(e) ? this.updateComponent(e) : e instanceof y ? this.updateRepeat(e) : Array.isArray(e) ? this.updateArray(e) : this.updateNode(e);
+  }
+  disposeComponent() {
+    this.componentInstance && (this.renderListener && this.componentInstance.removeRenderListener(this.renderListener), this.componentInstance.disconnectedCallback(), this.componentInstance = null, this.renderListener = null, this._clearTemplateCache());
+  }
+  updateComponent(e) {
+    this.componentInstance || (this.componentInstance = new e.clazz(), this.componentInstance.__parent = T.currentRenderingInstance, this.componentInstance.__parent && (this.componentInstance._id = `${this.componentInstance.__parent._id}:${this.componentInstance.__parent._childCounter++}`), this.renderListener = (t) => {
+      this.updateNode(t);
+    }, this.componentInstance.addRenderListener(this.renderListener), this.componentInstance.connectedCallback());
+    const s = this.componentInstance;
+    Object.assign(s, e.props), "props" in s && (s.props = e.props), s.children = e.children, s.requestUpdate();
+  }
+  updateRepeat(e) {
+    const { items: s, keyFn: t, templateFn: i } = e, r = /* @__PURE__ */ new Map();
+    this._childParts.forEach((p, m) => {
+      const f = this._partKeys[m];
+      f !== void 0 && r.set(f, p);
+    });
+    const a = [], c = [];
+    let d = this.startNode;
+    s.forEach((p, m) => {
+      const f = t(p, m);
+      c.push(f);
+      let _ = r.get(f);
+      _ ? (r.delete(f), _.startNode.previousSibling !== d && this.movePart(_, d), _.update(i(p, m))) : (_ = this.createChildPart(d), _.update(i(p, m))), a.push(_), d = _.endNode;
+    }), r.forEach((p) => p.dispose()), this._childParts = a, this._partKeys = c;
+  }
+  updateArray(e) {
+    this._partKeys = [];
+    const s = Math.min(e.length, this._childParts.length);
+    for (let t = 0; t < s; t++)
+      this._childParts[t].update(e[t]);
+    if (e.length > this._childParts.length) {
+      let t = this._childParts.length > 0 ? this._childParts[this._childParts.length - 1].endNode : this.startNode;
+      for (let i = s; i < e.length; i++) {
+        const r = this.createChildPart(t);
+        this._childParts.push(r), r.update(e[i]), t = r.endNode;
+      }
+    }
+    if (e.length < this._childParts.length)
+      for (let t = this._childParts.length - 1; t >= e.length; t--)
+        this._childParts[t].dispose(), this._childParts.pop();
+  }
+  createChildPart(e) {
+    const s = document.createComment("CRP-Item"), t = document.createComment("/CRP-Item"), i = e.nextSibling;
+    return e.parentNode.insertBefore(s, i), e.parentNode.insertBefore(t, i), new $(s, t);
+  }
+  movePart(e, s) {
+    const t = s.parentNode, i = [];
+    let r = e.startNode;
+    for (; r && r !== e.endNode; )
+      i.push(r), r = r.nextSibling;
+    i.push(e.endNode);
+    const a = s.nextSibling;
+    i.forEach((c) => t.insertBefore(c, a));
+  }
+  clearChildParts() {
+    this._childParts.forEach((e) => e.dispose()), this._childParts = [], this._partKeys = [];
+  }
+  dispose() {
+    this.clear(), this._clearTemplateCache(), this.clearChildParts(), this.startNode.parentNode && this.startNode.parentNode.removeChild(this.startNode), this.endNode.parentNode && this.endNode.parentNode.removeChild(this.endNode), this.componentInstance && (this.renderListener && this.componentInstance.removeRenderListener(this.renderListener), this.componentInstance.disconnectedCallback());
+  }
+  updateNode(e) {
+    var s;
+    if (this.startNode.parentNode)
+      if (S(e))
+        if (this._cachedTemplateStrings === e.strings && this._cachedParts)
+          this._cachedParts.forEach((t, i) => {
+            t.update(e.values[i]);
+          });
+        else {
+          this._clearTemplateCache(), this.clear();
+          const t = document.createDocumentFragment();
+          I(e, t), this.startNode.parentNode.insertBefore(t, this.endNode);
+          const i = M.get(((s = t.firstChild) == null ? void 0 : s.childNodes[0]) || t);
+          i && (this._cachedTemplateStrings = i.strings, this._cachedParts = i.parts);
+        }
+      else if (L(e) || typeof e == "object" && e !== null && !(e instanceof Node) && !Array.isArray(e)) {
+        this._clearTemplateCache(), this.clear();
+        const t = document.createDocumentFragment();
+        I(E`${e}`, t), this.startNode.parentNode.insertBefore(t, this.endNode);
+      } else if (U(e)) {
+        this._clearTemplateCache(), this.clear();
+        const t = document.createElement("template");
+        t.innerHTML = e.value, this.startNode.parentNode.insertBefore(t.content, this.endNode);
+      } else if (e instanceof Node)
+        this._clearTemplateCache(), this.clear(), this.startNode.parentNode.insertBefore(e, this.endNode);
+      else if (e == null || e === !1)
+        this._clearTemplateCache(), this.clear();
+      else {
+        const t = String(e), i = this.startNode.nextSibling;
+        if (i && i.nodeType === Node.TEXT_NODE && i.nextSibling === this.endNode)
+          i.nodeValue !== t && (i.nodeValue = t);
+        else {
+          this._clearTemplateCache(), this.clear();
+          const r = document.createTextNode(t);
+          this.startNode.parentNode.insertBefore(r, this.endNode);
+        }
+      }
+  }
+  _clearTemplateCache() {
+    this._cachedTemplateStrings = null, this._cachedParts = null;
+  }
+  clear() {
+    let e = this.startNode.nextSibling;
+    for (; e && e !== this.endNode; ) {
+      const s = e.nextSibling;
+      e.parentNode.removeChild(e), e = s;
+    }
+  }
+}
+class q {
+  constructor(e) {
+    h(this, "previousValues", {});
+    this.element = e;
+  }
+  update(e) {
+    if (typeof e != "object" || e === null) return;
+    const s = e;
+    for (const t of Object.keys(this.previousValues))
+      if (!(t in s))
+        if (t.startsWith("@")) {
+          const i = t.slice(1), r = `__crp_handler_${i}`, a = this.element[r];
+          a && this.element.removeEventListener(i, a);
+        } else t.startsWith(".") || (t.startsWith("?") ? this.element.removeAttribute(t.slice(1)) : this.element.removeAttribute(t));
+    for (const [t, i] of Object.entries(s))
+      if (t.startsWith("@") && typeof i == "function") {
+        const r = t.slice(1), a = `__crp_handler_${r}`, c = this.element[a];
+        c && this.element.removeEventListener(r, c), this.element[a] = i, this.element.addEventListener(r, i);
+      } else t.startsWith(".") ? this.element[t.slice(1)] = i : t.startsWith("?") ? i ? this.element.setAttribute(t.slice(1), "") : this.element.removeAttribute(t.slice(1)) : typeof i == "boolean" ? i ? this.element.setAttribute(t, "") : this.element.removeAttribute(t) : i != null && this.element.setAttribute(t, String(i));
+    this.previousValues = { ...s };
+  }
+}
+class v {
+  constructor(e, s) {
+    this.element = e, this.name = s;
+  }
+  update(e) {
+    let s = !1;
+    if (e instanceof R && (s = !0, e = e.value), this.name === "ref") {
+      typeof e == "function" ? e(this.element) : e && typeof e == "object" && "value" in e && (e.value = this.element), this.element.hasAttribute(this.name) && this.element.removeAttribute(this.name);
+      return;
+    }
+    if (this.name.startsWith("@") && typeof e == "function") {
+      const t = this.name.slice(1), i = `__crp_handler_${t}`, r = this.element[i];
+      r && this.element.removeEventListener(t, r), this.element[i] = e, this.element.addEventListener(t, e), this.element.hasAttribute(this.name) && this.element.removeAttribute(this.name);
+    } else if (this.name.startsWith(".")) {
+      const t = this.name.slice(1);
+      this.element[t] = e, this.element.hasAttribute(this.name) && this.element.removeAttribute(this.name);
+    } else if (this.name.startsWith("?")) {
+      const t = this.name.slice(1);
+      e ? this.element.setAttribute(t, "") : this.element.removeAttribute(t), this.element.hasAttribute(this.name) && this.element.removeAttribute(this.name);
+    } else if (this.name === "value" && (this.element instanceof HTMLInputElement || this.element instanceof HTMLTextAreaElement))
+      s ? this.element.value !== String(e) && (this.element.value = String(e)) : this.element.value !== String(e) && (this.element.value = String(e)), this.element.setAttribute(this.name, String(e));
+    else if (this.name === "checked" && this.element instanceof HTMLInputElement) {
+      const t = !!e;
+      this.element.checked !== t && (this.element.checked = t), t ? this.element.setAttribute(this.name, "") : this.element.removeAttribute(this.name);
+    } else typeof e == "boolean" ? e ? this.element.setAttribute(this.name, "") : this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, String(e));
+  }
+}
+const M = /* @__PURE__ */ new WeakMap(), I = (n, e) => {
+  const s = M.get(e);
+  if (s && s.strings === n.strings) {
+    s.parts.forEach((o, l) => {
+      o.update(n.values[l]);
+    });
+    return;
+  }
+  const t = [], i = n.values;
+  let r = "", a = !1;
+  const c = (o) => {
+    for (let l = 0; l < o.length; l++)
+      o[l] === "<" && o[l + 1] !== "!" && o[l + 1] !== "/" ? a = !0 : o[l] === ">" && (a = !1);
+  }, d = /(\.\.\.|[.@?]?[a-zA-Z0-9_-]+)=["']?$/;
+  for (let o = 0; o < n.strings.length - 1; o++) {
+    const l = n.strings[o];
+    c(l), r += l;
+    const u = l.match(d);
+    a && u ? r += `__CRP_${o}__` : r += `<!--CRP_${o}-->`;
+  }
+  const p = n.strings[n.strings.length - 1];
+  c(p), r += p;
+  const m = document.createElement("template");
+  m.innerHTML = r;
+  const f = m.content.cloneNode(!0), _ = document.createTreeWalker(f, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT);
+  let O;
+  const j = [];
+  for (; O = _.nextNode(); )
+    j.push(O);
+  j.forEach((o) => {
+    var l;
+    if (o.nodeType === Node.COMMENT_NODE) {
+      const u = (l = o.nodeValue) == null ? void 0 : l.match(/CRP_(\d+)/);
+      if (u) {
+        const C = parseInt(u[1]), P = document.createComment("/CRP");
+        o.parentNode.insertBefore(P, o.nextSibling);
+        const b = new $(o, P);
+        t[C] = b;
+      }
+    } else if (o.nodeType === Node.ELEMENT_NODE) {
+      const u = o;
+      Array.from(u.attributes).forEach((C) => {
+        const P = C.value.match(/__CRP_(\d+)__/);
+        if (P) {
+          const b = parseInt(P[1]);
+          if (!t[b])
+            if (C.name === "...") {
+              const w = new q(u);
+              t[b] = w, u.removeAttribute("...");
+            } else {
+              const w = new v(u, C.name);
+              t[b] = w;
+            }
+        }
+      });
+    }
+  });
+  for (let o = 0; o < i.length; o++)
+    t[o] && t[o].update(i[o]);
+  if (e instanceof HTMLElement)
+    e.innerHTML = "", e.appendChild(f);
+  else if (e instanceof DocumentFragment) {
+    for (; e.firstChild; )
+      e.removeChild(e.firstChild);
+    e.appendChild(f);
+  }
+  M.set(e, { strings: n.strings, parts: t });
+};
+export {
+  T as C,
+  R as L,
+  y as R,
+  B as T,
+  W as U,
+  U as a,
+  I as b,
+  Y as c,
+  g as d,
+  H as e,
+  x as f,
+  L as g,
+  E as h,
+  S as i,
+  X as j,
+  G as k,
+  Z as l,
+  J as m,
+  k as p,
+  A as r,
+  Q as s,
+  ee as u
+};

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { renderToString, escapeHtml } from './cossack-html';

package/dist/server.js

@@ -0,0 +1,5 @@
+import { e as a, r as o } from "./server-BEO1YttH.js";
+export {
+  a as escapeHtml,
+  o as renderToString
+};

package/dist/spread.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ssr-fixes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/syntax.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@cossackframework/renderer",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Light DOM rendering engine for the Cossack Framework",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cossackframework/cossack",
+    "directory": "packages/renderer"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server.js",
+      "types": "./dist/server.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest",
+    "lint": "oxlint"
+  },
+  "devDependencies": {
+    "htmlparser2": "^10.0.0",
+    "magic-string": "^0.30.21",
+    "oxlint": "^1.41.0",
+    "vite": "^5.3.5",
+    "vite-plugin-dts": "^3.9.1",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^1.2.2"
+  }
+}