@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/r-html/dist/render/part/node/text/index.js

@@ -0,0 +1,54 @@
+import { isNull } from "../../../../helpers/is-type.js";
+import _classPrivateFieldInitSpec from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { getMarkers } from "../../../../template/helper.js";
+import { domHelper } from "../../../helper.js";
+import { createPart, getPartType, isPart } from "./helper.js";
+//#region ../r-html/dist/render/part/node/text/index.js
+var _helper = /* @__PURE__ */ new WeakMap();
+var _startNode = /* @__PURE__ */ new WeakMap();
+var _endNode = /* @__PURE__ */ new WeakMap();
+var _markerTuple = /* @__PURE__ */ new WeakMap();
+var _value = /* @__PURE__ */ new WeakMap();
+var _part = /* @__PURE__ */ new WeakMap();
+var TextPart = class {
+	constructor(node, { value }, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_classPrivateFieldInitSpec(this, _startNode, void 0);
+		_classPrivateFieldInitSpec(this, _endNode, void 0);
+		_classPrivateFieldInitSpec(this, _markerTuple, void 0);
+		_classPrivateFieldInitSpec(this, _value, null);
+		_classPrivateFieldInitSpec(this, _part, null);
+		_classPrivateFieldSet2(_helper, this, helper);
+		_classPrivateFieldSet2(_startNode, this, helper.createMarker(""));
+		_classPrivateFieldSet2(_endNode, this, helper.createMarker(""));
+		_classPrivateFieldSet2(_markerTuple, this, getMarkers(value)[0]);
+		helper.insertBeforeNode(_classPrivateFieldGet2(_startNode, this), node);
+		helper.insertAfterNode(_classPrivateFieldGet2(_endNode, this), node);
+		helper.removeNode(node);
+	}
+	commit(values) {
+		const [, index] = _classPrivateFieldGet2(_markerTuple, this);
+		const newValue = values[index];
+		if (_classPrivateFieldGet2(_value, this) === newValue) return;
+		const type = getPartType(newValue);
+		if (!isPart(type, _classPrivateFieldGet2(_part, this))) {
+			isNull(_classPrivateFieldGet2(_part, this)) || this.clear();
+			_classPrivateFieldSet2(_part, this, createPart(type, _classPrivateFieldGet2(_startNode, this), _classPrivateFieldGet2(_endNode, this), _classPrivateFieldGet2(_helper, this)));
+		}
+		_classPrivateFieldGet2(_part, this)?.commit(newValue);
+		_classPrivateFieldSet2(_value, this, newValue);
+	}
+	clear() {
+		_classPrivateFieldGet2(_part, this)?.destroy?.();
+		_classPrivateFieldGet2(_helper, this).removeRange(_classPrivateFieldGet2(_startNode, this), _classPrivateFieldGet2(_endNode, this));
+	}
+	destroy() {
+		this.clear();
+		_classPrivateFieldGet2(_helper, this).removeNode(_classPrivateFieldGet2(_startNode, this));
+		_classPrivateFieldGet2(_helper, this).removeNode(_classPrivateFieldGet2(_endNode, this));
+	}
+};
+//#endregion
+export { TextPart };

package/dist/r-html/dist/render/part/node/text/node.js

@@ -0,0 +1,25 @@
+import _classPrivateFieldInitSpec from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { domHelper } from "../../../helper.js";
+//#region ../r-html/dist/render/part/node/text/node.js
+var _helper = /* @__PURE__ */ new WeakMap();
+var _endNode = /* @__PURE__ */ new WeakMap();
+var _value = /* @__PURE__ */ new WeakMap();
+var NodePart = class {
+	constructor(startNode, endNode, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_classPrivateFieldInitSpec(this, _endNode, void 0);
+		_classPrivateFieldInitSpec(this, _value, null);
+		_classPrivateFieldSet2(_endNode, this, endNode);
+		_classPrivateFieldSet2(_helper, this, helper);
+	}
+	commit(value) {
+		if (_classPrivateFieldGet2(_value, this) === value) return;
+		_classPrivateFieldGet2(_value, this) && _classPrivateFieldGet2(_helper, this).removeNode(_classPrivateFieldGet2(_value, this));
+		_classPrivateFieldGet2(_helper, this).insertBeforeNode(value, _classPrivateFieldGet2(_endNode, this));
+		_classPrivateFieldSet2(_value, this, value);
+	}
+};
+//#endregion
+export { NodePart };

package/dist/r-html/dist/render/part/node/text/object.js

@@ -0,0 +1,60 @@
+import _classPrivateFieldInitSpec from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { domHelper, isPromise, noop } from "../../../helper.js";
+import { createPart, getPartType } from "./helper.js";
+//#region ../r-html/dist/render/part/node/text/object.js
+var _helper = /* @__PURE__ */ new WeakMap();
+var _startNode = /* @__PURE__ */ new WeakMap();
+var _endNode = /* @__PURE__ */ new WeakMap();
+var _value = /* @__PURE__ */ new WeakMap();
+var _part = /* @__PURE__ */ new WeakMap();
+var _cancel = /* @__PURE__ */ new WeakMap();
+var ObjectPart = class {
+	constructor(startNode, endNode, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_classPrivateFieldInitSpec(this, _startNode, void 0);
+		_classPrivateFieldInitSpec(this, _endNode, void 0);
+		_classPrivateFieldInitSpec(this, _value, null);
+		_classPrivateFieldInitSpec(this, _part, null);
+		_classPrivateFieldInitSpec(this, _cancel, noop);
+		_classPrivateFieldSet2(_startNode, this, startNode);
+		_classPrivateFieldSet2(_endNode, this, endNode);
+		_classPrivateFieldSet2(_helper, this, helper);
+	}
+	commit(value) {
+		if (_classPrivateFieldGet2(_value, this) === value) return;
+		this.clear();
+		if (isPromise(value)) this.promiseCommit(value);
+	}
+	promiseCommit(promise) {
+		const [newPromise, cancel] = cancelPromise(promise);
+		_classPrivateFieldSet2(_cancel, this, cancel);
+		newPromise.then((value) => {
+			const type = getPartType(value);
+			_classPrivateFieldSet2(_part, this, createPart(type, _classPrivateFieldGet2(_startNode, this), _classPrivateFieldGet2(_endNode, this), _classPrivateFieldGet2(_helper, this)));
+			_classPrivateFieldGet2(_part, this)?.commit(value);
+		});
+		_classPrivateFieldSet2(_value, this, promise);
+	}
+	partClear() {
+		_classPrivateFieldGet2(_part, this)?.destroy?.();
+		_classPrivateFieldGet2(_helper, this).removeRange(_classPrivateFieldGet2(_startNode, this), _classPrivateFieldGet2(_endNode, this));
+	}
+	clear() {
+		_classPrivateFieldGet2(_cancel, this).call(this);
+		this.partClear();
+		_classPrivateFieldSet2(_cancel, this, noop);
+	}
+	destroy() {
+		this.clear();
+	}
+};
+function cancelPromise(promise) {
+	let cancelReject = noop;
+	const cancelPromise = new Promise((_, reject) => cancelReject = reject);
+	const cancel = () => cancelReject();
+	return [Promise.race([cancelPromise, promise]), cancel];
+}
+//#endregion
+export { ObjectPart };

package/dist/r-html/dist/render/part/node/text/primitive.js

@@ -0,0 +1,26 @@
+import { isNull, isUndefined } from "../../../../helpers/is-type.js";
+import _classPrivateFieldInitSpec from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { domHelper } from "../../../helper.js";
+//#region ../r-html/dist/render/part/node/text/primitive.js
+var _helper = /* @__PURE__ */ new WeakMap();
+var _textNode = /* @__PURE__ */ new WeakMap();
+var _value = /* @__PURE__ */ new WeakMap();
+var PrimitivePart = class {
+	constructor(startNode, endNode, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_classPrivateFieldInitSpec(this, _textNode, void 0);
+		_classPrivateFieldInitSpec(this, _value, null);
+		_classPrivateFieldSet2(_helper, this, helper);
+		_classPrivateFieldSet2(_textNode, this, helper.createText(""));
+		helper.insertAfterNode(_classPrivateFieldGet2(_textNode, this), startNode);
+	}
+	commit(value) {
+		if (_classPrivateFieldGet2(_value, this) === value) return;
+		_classPrivateFieldGet2(_helper, this).setText(_classPrivateFieldGet2(_textNode, this), isNull(value) || isUndefined(value) ? "" : String(value));
+		_classPrivateFieldSet2(_value, this, value);
+	}
+};
+//#endregion
+export { PrimitivePart };

package/dist/r-html/dist/render/part/node/text/templateLiterals.js

@@ -0,0 +1,38 @@
+import _classPrivateFieldInitSpec from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { domHelper } from "../../../helper.js";
+import { ContainerPart } from "../../container.js";
+//#region ../r-html/dist/render/part/node/text/templateLiterals.js
+var _helper = /* @__PURE__ */ new WeakMap();
+var _startNode = /* @__PURE__ */ new WeakMap();
+var _endNode = /* @__PURE__ */ new WeakMap();
+var _part = /* @__PURE__ */ new WeakMap();
+var TemplateLiteralsPart = class {
+	constructor(startNode, endNode, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_classPrivateFieldInitSpec(this, _startNode, void 0);
+		_classPrivateFieldInitSpec(this, _endNode, void 0);
+		_classPrivateFieldInitSpec(this, _part, null);
+		_classPrivateFieldSet2(_startNode, this, startNode);
+		_classPrivateFieldSet2(_endNode, this, endNode);
+		_classPrivateFieldSet2(_helper, this, helper);
+	}
+	commit(templateLiterals) {
+		const { strings, values } = templateLiterals;
+		if (_classPrivateFieldGet2(_part, this) && !_classPrivateFieldGet2(_part, this).equalStrings(strings)) {
+			_classPrivateFieldGet2(_part, this).destroy();
+			_classPrivateFieldSet2(_part, this, null);
+		}
+		if (!_classPrivateFieldGet2(_part, this)) {
+			_classPrivateFieldSet2(_part, this, new ContainerPart(templateLiterals, _classPrivateFieldGet2(_startNode, this), _classPrivateFieldGet2(_endNode, this), _classPrivateFieldGet2(_helper, this)));
+			_classPrivateFieldGet2(_part, this).insert("before", _classPrivateFieldGet2(_endNode, this));
+		}
+		_classPrivateFieldGet2(_part, this).commit(values);
+	}
+	destroy() {
+		_classPrivateFieldGet2(_part, this)?.destroy();
+	}
+};
+//#endregion
+export { TemplateLiteralsPart };

package/dist/r-html/dist/render/value.js

@@ -0,0 +1,8 @@
+import { isNull, isPrimitive, isUndefined } from "../helpers/is-type.js";
+import { isCSSTemplateLiterals } from "../template/helper.js";
+//#region ../r-html/dist/render/value.js
+function safeToString(value) {
+	return isPrimitive(value) && !isNull(value) && !isUndefined(value) || isCSSTemplateLiterals(value) ? String(value) : "";
+}
+//#endregion
+export { safeToString };

package/dist/r-html/dist/store/index.js

@@ -0,0 +1,72 @@
+import { asap, safeCallback } from "../helpers/fn.js";
+import { isFunction } from "../helpers/is-type.js";
+import { createSubject } from "../helpers/subject.js";
+import { observable } from "../observable/index.js";
+//#region ../r-html/dist/store/index.js
+function createAction(type) {
+	function actionCreator(payload) {
+		return {
+			type,
+			payload
+		};
+	}
+	actionCreator.toString = () => `${type}`;
+	actionCreator.type = type;
+	return actionCreator;
+}
+function* compositionActionsFlat$(state, ctx, iterator) {
+	for (const value of iterator) if (value?.[Symbol.iterator]) yield* compositionActionsFlat$(state, ctx, value);
+	else if (isFunction(value)) yield* compositionActionsFlat$(state, ctx, value(state, ctx));
+	else yield value;
+}
+var compositionActionsFlat = (state, ctx, compositionActions) => [...compositionActionsFlat$(state, ctx, compositionActions)];
+var pipe = (...operators) => (initSource) => operators.reduce((source, operator) => operator(source), initSource);
+function* createSource(actions) {
+	yield actions;
+}
+var notEmptyActions = function* (source) {
+	for (const actions of source) if (actions.length) yield actions;
+};
+function createStore({ context, state: initialState, reducers, enableObservable = true }) {
+	const state = enableObservable ? observable(initialState) : initialState;
+	const beforeSubject = createSubject();
+	const subject = createSubject();
+	let operator = pipe(notEmptyActions);
+	const runReducer = (action) => {
+		const reducer = Reflect.get(reducers, action.type, reducers);
+		safeCallback(reducer, state, action, context);
+	};
+	const dispatchSync = (...compositionActions) => {
+		const actions = compositionActionsFlat(state, context, compositionActions);
+		beforeSubject.next(actions);
+	};
+	const dispatch = (...compositionActions) => {
+		asap(() => dispatchSync(...compositionActions));
+	};
+	const connectUnsubscribe = beforeSubject.subscribe((actions) => {
+		const iter = operator(createSource(actions));
+		for (const value of iter) subject.next(value);
+	});
+	const unsubscribe = subject.subscribe((actions) => actions.forEach(runReducer));
+	const _pipe = (...operators) => {
+		operator = pipe(...operators, notEmptyActions);
+		return () => {
+			operator = pipe(notEmptyActions);
+		};
+	};
+	const destroy = () => {
+		connectUnsubscribe();
+		unsubscribe();
+	};
+	return {
+		context,
+		state,
+		dispatch,
+		dispatchSync,
+		subscribe: subject.subscribe,
+		pipe: _pipe,
+		destroy
+	};
+}
+//#endregion
+export { compositionActionsFlat, createAction, createStore };

package/dist/r-html/dist/template/css.js

@@ -0,0 +1,70 @@
+import { TEMPLATE_LITERALS } from "../constants.js";
+import { CSS_SOURCE, TemplateLiteralsType, cssTemplateCache } from "./index.js";
+import { vRender } from "./vCSSStyleSheet.js";
+import { isCSSDiagnosticsEnabled, reportCSSDiagnostics } from "./cssDiagnostics.js";
+import { compileToRules } from "../css/index.js";
+import { buildSource, classifySlots, slotText } from "./cssSource.js";
+//#region ../r-html/dist/template/css.js
+var MEMO_LIMIT = 32;
+var KEY_SEPARATOR = "\0";
+function createTag(mode) {
+	return (strings, ...values) => {
+		const template = getCSSTemplate(strings, mode);
+		const compiled = compileNode(template.node, values);
+		const identifier = vRender(compiled);
+		return {
+			strings,
+			values,
+			template,
+			[TEMPLATE_LITERALS]: TemplateLiteralsType.css,
+			[CSS_SOURCE]: compiled.source,
+			toString: () => identifier
+		};
+	};
+}
+var css = Object.assign(createTag("scoped"), { global: createTag("global") });
+function getCSSTemplate(strings, mode) {
+	const cached = cssTemplateCache.get(strings);
+	if (cached && cached.node.mode === mode) return cached;
+	const raw = strings.raw;
+	const node = {
+		raw,
+		slots: classifySlots(raw),
+		mode,
+		memo: /* @__PURE__ */ new Map()
+	};
+	const template = Object.freeze({ node });
+	cssTemplateCache.set(strings, template);
+	return template;
+}
+function compileNode(node, values) {
+	const key = node.slots.map((slot, index) => slotText(values[index], slot.kind)).join(KEY_SEPARATOR);
+	const memoized = node.memo.get(key);
+	if (memoized) return memoized;
+	const source = buildSource(node.raw, node.slots, values);
+	const { rules, canonicalText, identifier, cssText, diagnostics } = compileToRules(source, {
+		mode: node.mode,
+		dev: isCSSDiagnosticsEnabled()
+	});
+	const compiled = {
+		source,
+		mode: node.mode,
+		rules,
+		canonicalText,
+		identifier,
+		cssText
+	};
+	reportCSSDiagnostics(diagnostics, {
+		source,
+		identifier,
+		mode: node.mode
+	});
+	node.memo.set(key, compiled);
+	if (node.memo.size > MEMO_LIMIT) {
+		const [oldest] = node.memo.keys();
+		node.memo.delete(oldest);
+	}
+	return compiled;
+}
+//#endregion
+export { css };

package/dist/r-html/dist/template/cssDiagnostics.js

@@ -0,0 +1,23 @@
+//#region ../r-html/dist/template/cssDiagnostics.js
+var AMBIENT_FLAG = "__RHTML_CSS_DIAGNOSTICS__";
+var location = ({ line, column }) => line === void 0 ? "" : ` (${line}:${column ?? 1})`;
+var consoleDiagnosticHandler = (diagnostic, context) => {
+	const message = `[r-html] ${context.mode === "global" ? "css.global" : "css"} ${context.identifier}${location(diagnostic)} ${diagnostic.code}: ${diagnostic.message}`;
+	diagnostic.severity === "error" ? console.error(message) : console.warn(message);
+};
+function resolveHandler() {
+	const ambient = Reflect.get(globalThis, AMBIENT_FLAG);
+	if (!ambient) return null;
+	return typeof ambient === "function" ? ambient : consoleDiagnosticHandler;
+}
+function isCSSDiagnosticsEnabled() {
+	return resolveHandler() !== null;
+}
+function reportCSSDiagnostics(diagnostics, context) {
+	if (diagnostics.length === 0) return;
+	const handler = resolveHandler();
+	if (!handler) return;
+	for (const diagnostic of diagnostics) handler(diagnostic, context);
+}
+//#endregion
+export { consoleDiagnosticHandler, isCSSDiagnosticsEnabled, reportCSSDiagnostics };

package/dist/r-html/dist/template/cssSource.js

@@ -0,0 +1,62 @@
+import { isNull, isPrimitive, isUndefined } from "../helpers/is-type.js";
+import { CSS_SOURCE } from "./index.js";
+import { isCSSTemplateLiterals } from "./helper.js";
+//#region ../r-html/dist/template/cssSource.js
+function headSegment(raw) {
+	const match = /[;{}][^;{}]*$/.exec(raw);
+	return match ? match[0].slice(1) : raw;
+}
+function tailSegment(raw) {
+	const index = raw.search(/[;}\n]/);
+	return index === -1 ? raw : raw.slice(0, index);
+}
+function classifySlots(raw) {
+	const slots = [];
+	for (let i = 0; i < raw.length - 1; i++) {
+		const head = headSegment(raw[i]);
+		const tail = tailSegment(raw[i + 1]);
+		const kind = !head.includes(":") && !tail.includes("{") ? "statement" : "inline";
+		slots.push({
+			kind,
+			provable: head.trim().length === 0
+		});
+	}
+	return slots;
+}
+function terminate(source) {
+	const trimmed = source.trimEnd();
+	return !trimmed || trimmed.endsWith(";") || trimmed.endsWith("}") ? source : `${source};`;
+}
+function slotText(value, kind) {
+	if (isCSSTemplateLiterals(value)) return kind === "statement" ? terminate(value[CSS_SOURCE] ?? "") : `.${String(value)}`;
+	return isPrimitive(value) && !isNull(value) && !isUndefined(value) ? String(value) : "";
+}
+function report(slot, value, text) {
+	if (isCSSTemplateLiterals(value)) {
+		if (slot.kind === "statement" && !slot.provable) console.error("[r-html] a css literal follows unterminated text, so it is spliced in as a statement. End the declaration in front of it with a `;`.");
+		return;
+	}
+	if (text.includes("{") || text.includes("}")) {
+		console.warn(`[r-html] interpolated value contains a brace and is substituted before compiling, so it can change the rule structure: ${text}`);
+		return;
+	}
+	if (isUnbalanced(text, "'") || isUnbalanced(text, "\"")) console.warn(`[r-html] interpolated value has an unbalanced quote and is substituted before compiling: ${text}`);
+}
+function isUnbalanced(text, quote) {
+	let count = 0;
+	for (const char of text) if (char === quote) count++;
+	return count % 2 === 1;
+}
+function buildSource(raw, slots, values) {
+	let source = "";
+	for (let i = 0; i < raw.length; i++) {
+		source += raw[i];
+		if (i >= slots.length) continue;
+		const text = slotText(values[i], slots[i].kind);
+		report(slots[i], values[i], text);
+		source += text;
+	}
+	return source;
+}
+//#endregion
+export { buildSource, classifySlots, slotText, terminate };

package/dist/r-html/dist/template/helper.js

@@ -0,0 +1,37 @@
+import { isArray, isObject } from "../helpers/is-type.js";
+import { MARKER, SPREAD_MARKER, TAttrType, TEMPLATE_LITERALS, markerOnlyRegexp, markersRegexp } from "../constants.js";
+import { TemplateLiteralsType, TemplateLiteralsTypes } from "./index.js";
+//#region ../r-html/dist/template/helper.js
+var svgTypes = /* @__PURE__ */ new Set([TemplateLiteralsType.svg]);
+var createMarker = (index) => `${MARKER}_${index}_`;
+var isTemplateStringsArray = (value) => isArray(value) && isArray(value.raw);
+var isTemplateLiterals = (value) => isObject(value) && isTemplateStringsArray(value.strings) && isArray(value.values) && TemplateLiteralsTypes.has(Reflect.get(value, TEMPLATE_LITERALS) ?? "");
+var isCSSTemplateLiterals = (value) => isTemplateLiterals(value) && value[TEMPLATE_LITERALS] === TemplateLiteralsType.css;
+var createIsMarker = (marker, prefix = true, suffix = false) => (value) => {
+	if (prefix) return Boolean(value?.trimStart().startsWith(marker));
+	if (suffix) return Boolean(value?.trimEnd().endsWith(marker));
+	return new RegExp(marker).test(value ?? "");
+};
+var isPrefixSpreadMarker = createIsMarker(SPREAD_MARKER);
+var isPrefixPropertyMarker = createIsMarker(".");
+var isPrefixBooleanMarker = createIsMarker("?");
+var isPrefixEventMarker = createIsMarker("@");
+var isPrefixOnEventMarker = createIsMarker("on");
+var isMarker = createIsMarker(MARKER, false);
+var isMarkerOnly = (value) => isMarker(value) && markerOnlyRegexp.test(value?.trim() ?? "");
+var isPartAttr = ({ type, value }) => type === TAttrType.spread || type === TAttrType.directive || isMarker(value);
+var isSVG = (type) => svgTypes.has(type);
+var getAttrType = (value) => isMarkerOnly(value) ? TAttrType.directive : isPrefixSpreadMarker(value) ? TAttrType.spread : isPrefixPropertyMarker(value) ? TAttrType.property : isPrefixEventMarker(value) || isPrefixOnEventMarker(value) ? TAttrType.event : isPrefixBooleanMarker(value) ? TAttrType.boolean : TAttrType.attribute;
+var getAttrName = (value) => isPrefixSpreadMarker(value) ? value.substring(3) : isMarkerOnly(value) ? value : isPrefixPropertyMarker(value) || isPrefixEventMarker(value) || isPrefixBooleanMarker(value) ? value.substring(1) : isPrefixOnEventMarker(value) ? value.substring(2) : value;
+function getMarkers(value) {
+	const markers = [];
+	let match = markersRegexp.exec(value);
+	while (match) {
+		const index = Number(match[1]);
+		markers.push([match[0], Number.isInteger(index) ? index : -1]);
+		match = markersRegexp.exec(value);
+	}
+	return markers;
+}
+//#endregion
+export { createMarker, getAttrName, getAttrType, getMarkers, isCSSTemplateLiterals, isMarker, isMarkerOnly, isPartAttr, isPrefixBooleanMarker, isPrefixEventMarker, isPrefixOnEventMarker, isPrefixPropertyMarker, isPrefixSpreadMarker, isSVG, isTemplateLiterals, isTemplateStringsArray };

package/dist/r-html/dist/template/html.js

@@ -0,0 +1,29 @@
+import { TEMPLATE_LITERALS } from "../constants.js";
+import { TemplateLiteralsType, templateCache } from "./index.js";
+import { createMarker } from "./helper.js";
+import { htmlParser } from "../parser/html/index.js";
+import { createTNode } from "./tNode.js";
+//#region ../r-html/dist/template/html.js
+var createTagged = (type) => (strings, ...values) => {
+	const templateLiterals = {
+		strings,
+		values,
+		[TEMPLATE_LITERALS]: type
+	};
+	if (templateCache.has(strings)) {
+		templateLiterals.template = templateCache.get(strings);
+		return templateLiterals;
+	}
+	const tpl = strings.reduce((acc, cur, i) => {
+		i < values.length ? acc.push(cur, createMarker(i)) : acc.push(cur);
+		return acc;
+	}, []).join("");
+	const node = createTNode(htmlParser(tpl));
+	templateLiterals.template = Object.freeze({ node });
+	templateCache.set(strings, templateLiterals.template);
+	return templateLiterals;
+};
+var html = createTagged(TemplateLiteralsType.html);
+var svg = createTagged(TemplateLiteralsType.svg);
+//#endregion
+export { html, svg };

package/dist/r-html/dist/template/index.js

@@ -0,0 +1,13 @@
+//#region ../r-html/dist/template/index.js
+var TemplateLiteralsType = /* @__PURE__ */ function(TemplateLiteralsType) {
+	TemplateLiteralsType["html"] = "html";
+	TemplateLiteralsType["svg"] = "svg";
+	TemplateLiteralsType["css"] = "css";
+	return TemplateLiteralsType;
+}({});
+var TemplateLiteralsTypes = new Set(Object.values(TemplateLiteralsType));
+var CSS_SOURCE = Symbol.for("https://github.com/dineug/r-html#CSSSource");
+var templateCache = /* @__PURE__ */ new WeakMap();
+var cssTemplateCache = /* @__PURE__ */ new WeakMap();
+//#endregion
+export { CSS_SOURCE, TemplateLiteralsType, TemplateLiteralsTypes, cssTemplateCache, templateCache };

package/dist/r-html/dist/template/tNode.js

@@ -0,0 +1,107 @@
+import { MARKER, TAttrType, markersRegexp, nextLineRegexp } from "../constants.js";
+import { getAttrName, getAttrType, getMarkers, isMarker, isMarkerOnly, isPartAttr } from "./helper.js";
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+import { VNode, VNodeType } from "../parser/vNode.js";
+import { groupBy } from "../helpers/array.js";
+//#region ../r-html/dist/template/tNode.js
+var _Symbol$iterator = Symbol.iterator;
+var TNode = class TNode {
+	get isMarker() {
+		return isMarker(this.value);
+	}
+	get isMarkerOnly() {
+		return isMarkerOnly(this.value);
+	}
+	get isSvg() {
+		return this.type === VNodeType.element && /^svg$/i.test(this.value);
+	}
+	get isComponent() {
+		return this.type === VNodeType.element && this.isMarkerOnly;
+	}
+	constructor(node, parent = null) {
+		_defineProperty(this, "type", VNodeType.comment);
+		_defineProperty(this, "value", "");
+		_defineProperty(this, "staticAttrs", void 0);
+		_defineProperty(this, "attrs", void 0);
+		_defineProperty(this, "parent", null);
+		_defineProperty(this, "children", void 0);
+		this.type = node.type;
+		this.value = node.value;
+		this.parent = parent;
+		if (node.attrs) {
+			const [staticAttrs, partAttrs] = createAttrsTuple(node.attrs);
+			staticAttrs.length && (this.staticAttrs = staticAttrs);
+			partAttrs.length && (this.attrs = partAttrs);
+		}
+		node.children && (this.children = node.children.map((child) => new TNode(child, this)));
+	}
+	insert(position, newChild, refChild) {
+		if (this.children) {
+			const pos = position === "before" ? 0 : 1;
+			this.children.includes(refChild) && this.children.splice(this.children.indexOf(refChild) + pos, 0, newChild);
+		} else this.children = [newChild];
+	}
+	*iterParent() {
+		yield this;
+		if (!this.parent) return;
+		yield* this.parent.iterParent();
+	}
+	*[_Symbol$iterator]() {
+		yield this;
+		if (!this.children) return;
+		for (const node of this.children) yield* node;
+	}
+};
+function createTNode(vNode) {
+	const tNode = new TNode(vNode);
+	for (const node of tNode) if (node.type === VNodeType.text && !isMarkerOnly(node.value)) splitTextNode(node);
+	return tNode;
+}
+function splitTextNode(node) {
+	const markers = getMarkers(node.value);
+	node.value.replace(markersRegexp, MARKER).split(MARKER).reduce((acc, value, i) => {
+		i < markers.length ? acc.push(new TNode(new VNode({
+			type: VNodeType.text,
+			value
+		}), node.parent), new TNode(new VNode({
+			type: VNodeType.text,
+			value: markers[i][0]
+		}), node.parent)) : acc.push(new TNode(new VNode({
+			type: VNodeType.text,
+			value
+		}), node.parent));
+		return acc;
+	}, []).filter((node) => node.value !== "" && !(!node.value.trim() && nextLineRegexp.test(node.value))).reverse().forEach((textNode, index, { length }) => index === length - 1 ? node.value = textNode.value : node.parent && node.parent.insert("after", textNode, node));
+}
+function createAttrsTuple(attrs = []) {
+	const groupMap = groupBy(attrs, (attr) => getAttrName(attr.name));
+	return Object.keys(groupMap).map((k) => groupMap[k]).reduce((acc, attrGroup) => {
+		const [staticAttrs, partAttrs] = acc;
+		const lastAttr = attrGroup[attrGroup.length - 1];
+		const type = getAttrType(lastAttr.name);
+		if (type === TAttrType.event) partAttrs.push(...attrGroup.filter((attr) => Boolean(attr.value)).map((attr) => ({
+			type: getAttrType(attr.name),
+			name: getAttrName(attr.name),
+			value: attr.value
+		})));
+		else if (type === TAttrType.attribute) {
+			const value = attrGroup.filter((attr) => Boolean(attr.value)).map((attr) => attr.value).join(" ");
+			const newAttr = {
+				type,
+				name: getAttrName(lastAttr.name)
+			};
+			value && (newAttr.value = value);
+			isPartAttr(newAttr) ? partAttrs.push(newAttr) : staticAttrs.push(newAttr);
+		} else {
+			const newAttr = {
+				type,
+				name: getAttrName(lastAttr.name)
+			};
+			lastAttr.value && (newAttr.value = lastAttr.value);
+			isPartAttr(newAttr) ? partAttrs.push(newAttr) : staticAttrs.push(newAttr);
+		}
+		return acc;
+	}, [[], []]);
+}
+//#endregion
+export { TNode, createTNode };