@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,195 @@
+import { SCOPE, isShadowBoundary } from "./selector.js";
+import { childrenOf, declarationsOf, isAtRule, isConditionalAtRule, isDeclaration, isRuleset, stepsOf } from "./element.js";
+import { CHARSET, IMPORT, LAYER, NAMESPACE } from "stylis";
+//#region ../r-html/dist/css/diagnostics.js
+var STATEMENT_AT_RULES = /* @__PURE__ */ new Set([
+	IMPORT,
+	CHARSET,
+	NAMESPACE,
+	LAYER
+]);
+function collectDiagnostics(elements, rules, options) {
+	const diagnostics = [];
+	const keyframes = /* @__PURE__ */ new Set();
+	let ruleSeen = false;
+	const walk = (nodes, scoped) => {
+		for (const node of nodes) {
+			if (isRuleset(node)) {
+				ruleSeen = true;
+				reportRuleset(node, scoped, diagnostics);
+				continue;
+			}
+			if (!isAtRule(node)) continue;
+			if (childrenOf(node).length === 0) {
+				if (!STATEMENT_AT_RULES.has(node.type)) continue;
+				diagnostics.push({
+					code: "unsupported-at-rule",
+					severity: "error",
+					message: `\`${node.value}\` is not supported and was dropped. A constructed stylesheet strips \`@import\` by spec, and happy-dom discards the entire sheet when it sees any body-less at-rule — with one sheet per template that would erase the whole component. Move it to a \`<link>\`.`,
+					line: node.line,
+					column: node.column
+				});
+				if (node.type === IMPORT && ruleSeen) diagnostics.push({
+					code: "import-after-rule",
+					severity: "warning",
+					message: `\`${node.value}\` follows a rule. Even where \`@import\` is supported it has to precede every rule in the sheet, so this one could not have applied.`,
+					line: node.line,
+					column: node.column
+				});
+				continue;
+			}
+			ruleSeen = true;
+			if (isConditionalAtRule(node.type)) {
+				walk(childrenOf(node), scoped);
+				continue;
+			}
+			if (stepsOf(node).length > 0) reportKeyframes(node, keyframes, diagnostics);
+			walk(childrenOf(node), false);
+		}
+	};
+	walk(elements, options.scoped);
+	if (!options.scoped && elements.some(isDeclaration)) diagnostics.push({
+		code: "rule-without-selector",
+		severity: "warning",
+		message: "Declarations at the top level of a global block have no selector and were dropped. Wrap them in one."
+	});
+	reportScopeInDeclarations(rules, diagnostics);
+	const unterminated = findUnterminated(options.source);
+	if (unterminated) diagnostics.push(unterminated);
+	return diagnostics;
+}
+function reportRuleset(element, scoped, diagnostics) {
+	if (element.props.every((selector) => selector.length === 0)) {
+		const declarations = declarationsOf(element);
+		if (declarations.length > 0) diagnostics.push({
+			code: "rule-without-selector",
+			severity: "warning",
+			message: `A rule with no selector was dropped: \`{${declarations.join(";")}}\`.`,
+			line: element.line,
+			column: element.column
+		});
+	}
+	if (!scoped) return;
+	for (const segment of splitSelectorList(element.value)) {
+		const selector = segment.trim();
+		if (isShadowBoundary(selector)) {
+			diagnostics.push({
+				code: "shadow-boundary",
+				severity: "warning",
+				message: `\`${selector}\` crosses a shadow boundary, but a scoped block prepends the component class to it, so it can never match. Use \`css.global\` for this rule.`,
+				line: element.line,
+				column: element.column
+			});
+			continue;
+		}
+		if (selector.charCodeAt(0) === 58) diagnostics.push({
+			code: "implicit-descendant",
+			severity: "warning",
+			message: `\`${selector}\` becomes a descendant of the scope, not a qualifier on it. Prefix it with \`&\` to attach it: \`&${selector}\`.`,
+			line: element.line,
+			column: element.column
+		});
+	}
+}
+function reportKeyframes(element, seen, diagnostics) {
+	if (seen.has(element.value)) {
+		diagnostics.push({
+			code: "duplicate-keyframes",
+			severity: "warning",
+			message: `\`${element.value}\` is defined more than once. The name is global and unscoped, so the last definition wins for every template that animates with it.`,
+			line: element.line,
+			column: element.column
+		});
+		return;
+	}
+	seen.add(element.value);
+}
+function reportScopeInDeclarations(rules, diagnostics) {
+	for (const rule of rules) for (const declaration of rule.declarations) {
+		if (!declaration.includes("rhtml-scope")) continue;
+		diagnostics.push({
+			code: "scope-in-declaration",
+			severity: "warning",
+			message: `\`${declaration}\` contains \`${SCOPE}\`. The sentinel is only substituted in selectors, so it will reach the browser as written.`
+		});
+	}
+}
+function splitSelectorList(value) {
+	const segments = [];
+	let depth = 0;
+	let quote = 0;
+	let start = 0;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (quote !== 0) {
+			if (code === quote && value.charCodeAt(i - 1) !== 92) quote = 0;
+		} else if (code === 34 || code === 39) quote = code;
+		else if (code === 40 || code === 91) depth++;
+		else if (code === 41 || code === 93) depth--;
+		else if (code === 44 && depth === 0) {
+			segments.push(value.slice(start, i));
+			start = i + 1;
+		}
+	}
+	segments.push(value.slice(start));
+	return segments;
+}
+function findUnterminated(source) {
+	let line = 1;
+	let column = 1;
+	let index = 0;
+	const step = () => {
+		if (source.charCodeAt(index) === 10) {
+			line++;
+			column = 1;
+		} else column++;
+		index++;
+	};
+	while (index < source.length) {
+		const code = source.charCodeAt(index);
+		const next = source.charCodeAt(index + 1);
+		if (code === 47 && next === 42) {
+			const openLine = line;
+			const openColumn = column;
+			step();
+			step();
+			while (index < source.length && !(source.charCodeAt(index) === 42 && source.charCodeAt(index + 1) === 47)) step();
+			if (index >= source.length) return {
+				code: "unterminated-comment",
+				severity: "warning",
+				message: "Unterminated block comment. The scanner consumed the rest of the source, so every rule after it was lost.",
+				line: openLine,
+				column: openColumn
+			};
+			step();
+			step();
+			continue;
+		}
+		if (code === 47 && next === 47) {
+			while (index < source.length && source.charCodeAt(index) !== 10) step();
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			const openLine = line;
+			const openColumn = column;
+			step();
+			while (index < source.length && source.charCodeAt(index) !== code) {
+				if (source.charCodeAt(index) === 92) step();
+				step();
+			}
+			if (index >= source.length) return {
+				code: "unterminated-string",
+				severity: "warning",
+				message: "Unterminated string. The scanner consumed the rest of the source, so every rule after it was lost.",
+				line: openLine,
+				column: openColumn
+			};
+			step();
+			continue;
+		}
+		step();
+	}
+	return null;
+}
+//#endregion
+export { collectDiagnostics };

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

@@ -0,0 +1,34 @@
+import { DECLARATION, RULESET } from "stylis";
+//#region ../r-html/dist/css/element.js
+function isRuleset(element) {
+	return element.type === RULESET;
+}
+function isDeclaration(element) {
+	return element.type === DECLARATION;
+}
+function isAtRule(element) {
+	return element.type.charCodeAt(0) === 64;
+}
+function childrenOf(element) {
+	return Array.isArray(element.children) ? element.children : [];
+}
+function declarationText(element) {
+	return element.value.charCodeAt(element.value.length - 1) === 59 ? element.value.slice(0, -1) : element.value;
+}
+function declarationsOf(element) {
+	const declarations = [];
+	for (const child of childrenOf(element)) if (isDeclaration(child)) declarations.push(declarationText(child));
+	return declarations;
+}
+function stepsOf(element) {
+	return childrenOf(element).filter(isRuleset);
+}
+function isConditionalAtRule(type) {
+	const kind = type.charCodeAt(1);
+	if (kind === 100 || kind === 109 || kind === 115) return true;
+	if (kind === 99 && type.charCodeAt(3) === 110) return true;
+	if (kind === 99 || kind === 108) return type.charCodeAt(2) === 97;
+	return false;
+}
+//#endregion
+export { childrenOf, declarationText, declarationsOf, isAtRule, isConditionalAtRule, isDeclaration, isRuleset, stepsOf };

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

@@ -0,0 +1,26 @@
+import { substituteScope } from "./selector.js";
+//#region ../r-html/dist/css/emit.js
+function emit(rules, options = {}) {
+	let output = "";
+	let open = [];
+	for (const rule of rules) {
+		const { conditions } = rule;
+		let common = 0;
+		while (common < open.length && common < conditions.length && open[common] === conditions[common]) common++;
+		for (let i = common; i < open.length; i++) output += "}";
+		for (let i = common; i < conditions.length; i++) output += `${conditions[i]}{`;
+		open = conditions;
+		output += emitRule(rule, options.scope);
+	}
+	for (let i = 0; i < open.length; i++) output += "}";
+	return output;
+}
+function emitRule(rule, scope) {
+	if (rule.body !== void 0) return `${rule.prelude}{${rule.body}}`;
+	return `${rule.prelude ?? emitSelectors(rule.selectors, scope)}{${rule.declarations.join(";")};}`;
+}
+function emitSelectors(selectors, scope) {
+	return (scope === void 0 ? selectors : selectors.map((selector) => substituteScope(selector, scope))).join(",");
+}
+//#endregion
+export { emit };

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

@@ -0,0 +1,76 @@
+import { childrenOf, declarationText, declarationsOf, isAtRule, isConditionalAtRule, isDeclaration, isRuleset, stepsOf } from "./element.js";
+import { emit } from "./emit.js";
+//#region ../r-html/dist/css/flatten.js
+var NO_CONDITIONS = [];
+var isNotEmpty = (value) => value.length > 0;
+function flatten(elements, options) {
+	const collected = [];
+	walk(elements, NO_CONDITIONS, options.rules, collected);
+	return (options.plugins ?? []).reduce((rules, plugin) => rules.flatMap((rule) => plugin(rule)), collected).filter(isEmittable);
+}
+function isEmittable(rule) {
+	const hasHead = rule.selectors.length > 0 || rule.prelude !== void 0;
+	const hasBody = rule.declarations.length > 0 || Boolean(rule.body);
+	return hasHead && hasBody;
+}
+function walk(elements, conditions, rules, collected) {
+	const start = collected.length;
+	const rootDeclarations = [];
+	for (const element of elements) if (isDeclaration(element)) rootDeclarations.push(declarationText(element));
+	else if (isRuleset(element)) appendStyleRule(element, conditions, collected);
+	else if (isAtRule(element)) appendAtRule(element, conditions, rules, collected);
+	if (rootDeclarations.length === 0) return;
+	const selectors = rules.filter(isNotEmpty);
+	if (selectors.length === 0) return;
+	collected.splice(start, 0, {
+		conditions,
+		selectors,
+		declarations: rootDeclarations
+	});
+}
+function appendStyleRule(element, conditions, collected) {
+	const selectors = element.props.filter(isNotEmpty);
+	if (selectors.length === 0) return;
+	const declarations = declarationsOf(element);
+	if (declarations.length === 0) return;
+	collected.push({
+		conditions,
+		selectors,
+		declarations
+	});
+}
+function appendAtRule(element, conditions, rules, collected) {
+	const children = childrenOf(element);
+	if (children.length === 0) return;
+	if (isConditionalAtRule(element.type)) {
+		const nested = [];
+		walk(children, [...conditions, element.value], rules, nested);
+		if (nested.length === 0) return;
+		for (const rule of nested) collected.push(rule);
+		return;
+	}
+	const steps = stepsOf(element);
+	if (steps.length > 0) {
+		const stepRules = [];
+		for (const step of steps) appendStyleRule(step, NO_CONDITIONS, stepRules);
+		const body = emit(stepRules);
+		if (body) collected.push({
+			conditions,
+			selectors: [],
+			prelude: element.value,
+			declarations: [],
+			body
+		});
+		return;
+	}
+	const declarations = declarationsOf(element);
+	if (declarations.length === 0) return;
+	collected.push({
+		conditions,
+		selectors: [],
+		prelude: element.value,
+		declarations
+	});
+}
+//#endregion
+export { flatten };

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

@@ -0,0 +1,15 @@
+//#region ../r-html/dist/css/hash.js
+function fnv1a32(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+var IDENTIFIER_LENGTH = 7;
+function toIdentifier(text) {
+	return `_${fnv1a32(text).toString(36).padStart(IDENTIFIER_LENGTH, "0")}`;
+}
+//#endregion
+export { fnv1a32, toIdentifier };

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

@@ -0,0 +1,31 @@
+import { compile } from "./compile.js";
+import { SCOPE } from "./selector.js";
+import { collectDiagnostics } from "./diagnostics.js";
+import { emit } from "./emit.js";
+import { flatten } from "./flatten.js";
+import { toIdentifier } from "./hash.js";
+//#region ../r-html/dist/css/index.js
+var NO_DIAGNOSTICS = [];
+function compileToRules(source, options = {}) {
+	const scoped = options.mode !== "global";
+	const rules = scoped ? [SCOPE] : [""];
+	const elements = compile(source, { rules });
+	const flattened = flatten(elements, {
+		rules,
+		plugins: options.plugins
+	});
+	const canonicalText = emit(flattened);
+	const identifier = toIdentifier(canonicalText);
+	return {
+		rules: flattened,
+		canonicalText,
+		identifier,
+		cssText: emit(flattened, { scope: `.${identifier}` }),
+		diagnostics: options.dev ? collectDiagnostics(elements, flattened, {
+			source,
+			scoped
+		}) : NO_DIAGNOSTICS
+	};
+}
+//#endregion
+export { compileToRules };

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

@@ -0,0 +1,11 @@
+//#region ../r-html/dist/css/selector.js
+var SCOPE = "rhtml-scope";
+function substituteScope(selector, scope) {
+	return selector.split(SCOPE).join(scope);
+}
+var SHADOW_BOUNDARY = /^(?::host\b|::slotted\()/;
+function isShadowBoundary(segment) {
+	return SHADOW_BOUNDARY.test(segment.trim());
+}
+//#endregion
+export { SCOPE, isShadowBoundary, substituteScope };

package/dist/r-html/dist/helpers/array.js

@@ -0,0 +1,9 @@
+//#region ../r-html/dist/helpers/array.js
+var groupBy = (list, identity) => list.reduce((acc, cur) => {
+	const key = identity(cur);
+	const arr = acc[key];
+	arr ? arr.push(cur) : acc[key] = [cur];
+	return acc;
+}, Object.create(null));
+//#endregion
+export { groupBy };

package/dist/r-html/dist/helpers/fn.js

@@ -0,0 +1,14 @@
+//#region ../r-html/dist/helpers/fn.js
+function safeCallback(callback, ...args) {
+	try {
+		return callback?.(...args);
+	} catch (e) {
+		console.error(e);
+	}
+}
+var queueMicrotaskFallback = (callback) => {
+	Promise.resolve().then(callback);
+};
+var asap = queueMicrotask ?? queueMicrotaskFallback;
+//#endregion
+export { asap, safeCallback };

package/dist/r-html/dist/helpers/is-type.js

@@ -0,0 +1,16 @@
+//#region ../r-html/dist/helpers/is-type.js
+var createIsTypeof = (type) => (value) => typeof value === type;
+var isObjectRaw = createIsTypeof("object");
+var isBigint = createIsTypeof("bigint");
+var isBoolean = createIsTypeof("boolean");
+var isFunction = createIsTypeof("function");
+var isNumber = createIsTypeof("number");
+var isString = createIsTypeof("string");
+var isSymbol = createIsTypeof("symbol");
+var isUndefined = createIsTypeof("undefined");
+var isNull = (value) => value === null;
+var { isArray } = Array;
+var isObject = (value) => isObjectRaw(value) && !isNull(value) && !isArray(value);
+var isPrimitive = (value) => isBigint(value) || isBoolean(value) || isNumber(value) || isString(value) || isSymbol(value) || isUndefined(value) || isNull(value);
+//#endregion
+export { isArray, isBigint, isBoolean, isFunction, isNull, isNumber, isObject, isObjectRaw, isPrimitive, isString, isSymbol, isUndefined };

package/dist/r-html/dist/helpers/subject.js

@@ -0,0 +1,21 @@
+//#region ../r-html/dist/helpers/subject.js
+function createSubject() {
+	const observers = /* @__PURE__ */ new Set();
+	const subscribe = (fn) => {
+		observers.has(fn) || observers.add(fn);
+		return () => {
+			observers.delete(fn);
+		};
+	};
+	const next = (value) => {
+		observers.forEach((fn) => fn(value));
+	};
+	const asReadonly = () => ({ subscribe });
+	return {
+		subscribe,
+		next,
+		asReadonly
+	};
+}
+//#endregion
+export { createSubject };

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

@@ -0,0 +1,78 @@
+import { safeCallback } from "../helpers/fn.js";
+import { isArray, isObject } from "../helpers/is-type.js";
+import { createSubject } from "../helpers/subject.js";
+import { addHmrObservable } from "../render/hmr.js";
+import { cancelTask, effect, watchEffect } from "./scheduler.js";
+//#region ../r-html/dist/observable/index.js
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+var rawToObservers = /* @__PURE__ */ new WeakMap();
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+var proxyToSubject = /* @__PURE__ */ new WeakMap();
+var observerToTriggers = /* @__PURE__ */ new WeakMap();
+var defaultObservableOptions = { shallow: false };
+var currentObserver = null;
+function observer(f) {
+	currentObserver = f;
+	safeCallback(f);
+	currentObserver = null;
+	return () => unobserve(f);
+}
+function unobserve(observer) {
+	cancelTask(observer);
+	const triggers = observerToTriggers.get(observer);
+	if (triggers) for (const [raw] of triggers.entries()) rawToObservers.get(raw)?.delete(observer);
+	triggers && observerToTriggers.delete(observer);
+}
+function addObserver(raw) {
+	if (!currentObserver) return;
+	const observers = rawToObservers.get(raw);
+	if (!observers) rawToObservers.set(raw, /* @__PURE__ */ new Set([currentObserver]));
+	else if (!observers.has(currentObserver)) observers.add(currentObserver);
+}
+function addTrigger(raw, p) {
+	if (!currentObserver) return;
+	const triggers = observerToTriggers.get(currentObserver);
+	if (triggers) {
+		const trigger = triggers.get(raw);
+		if (!trigger) triggers.set(raw, /* @__PURE__ */ new Set([p]));
+		else if (!trigger.has(p)) trigger.add(p);
+	} else observerToTriggers.set(currentObserver, /* @__PURE__ */ new Map([[raw, /* @__PURE__ */ new Set([p])]]));
+}
+var exclude = (value) => value instanceof Node || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet || value instanceof RegExp || value instanceof Date || value instanceof Promise || (isArray(value) || isObject(value)) && Object.isFrozen(value);
+function observable(raw, options = {}) {
+	const { shallow } = Object.assign({}, defaultObservableOptions, options);
+	const proxy = new Proxy(raw, {
+		get(target, p, receiver) {
+			const value = Reflect.get(target, p, receiver);
+			if (exclude(value)) return value;
+			addObserver(raw);
+			addTrigger(raw, p);
+			if (!shallow && (isObject(value) || isArray(value)) && !proxyToRaw.has(value)) return rawToProxy.has(value) ? rawToProxy.get(value) : observable(value, options);
+			return value;
+		},
+		set(target, p, value, receiver) {
+			const oldValue = Reflect.get(target, p, receiver);
+			const res = Reflect.set(target, p, value, receiver);
+			if (!isArray(target) && oldValue !== value ? true : p === "length") {
+				effect(target, p);
+				watchEffect(target, p);
+			}
+			return res;
+		},
+		deleteProperty(target, p) {
+			const res = Reflect.deleteProperty(target, p);
+			effect(target, p);
+			watchEffect(target, p);
+			return res;
+		}
+	});
+	rawToProxy.set(raw, proxy);
+	proxyToRaw.set(proxy, raw);
+	addHmrObservable(proxy);
+	return proxy;
+}
+function watch(proxy) {
+	return (proxyToSubject.get(proxy) ?? proxyToSubject.set(proxy, createSubject()).get(proxy)).asReadonly();
+}
+//#endregion
+export { observable, observer, observerToTriggers, proxyToSubject, rawToObservers, rawToProxy, unobserve, watch };

package/dist/r-html/dist/observable/scheduler.js

@@ -0,0 +1,84 @@
+import { asap, safeCallback } from "../helpers/fn.js";
+import { observer, observerToTriggers, proxyToSubject, rawToObservers, rawToProxy, unobserve } from "./index.js";
+//#region ../r-html/dist/observable/scheduler.js
+var queue = [];
+var queueMap = /* @__PURE__ */ new Map();
+var watchQueue = /* @__PURE__ */ new Map();
+var executable = true;
+function isTrigger(raw, p, observer) {
+	const triggers = observerToTriggers.get(observer);
+	if (!triggers) return false;
+	const trigger = triggers.get(raw);
+	if (!trigger) return false;
+	return trigger.has(p);
+}
+var createNextTick = (type) => (fn) => {
+	const prevTask = queueMap.get(fn);
+	let next = () => {};
+	const promise = prevTask?.promise ? prevTask.promise : new Promise((resolve) => {
+		next = resolve;
+	});
+	if (!prevTask) {
+		const task = {
+			type,
+			promise,
+			fn,
+			resolve: () => {
+				next();
+			}
+		};
+		queue.push(task);
+		queueMap.set(fn, task);
+	}
+	if (executable) {
+		asap(executeAsap);
+		executable = false;
+	}
+	return promise;
+};
+var observerNextTick = createNextTick("observer");
+var nextTick = createNextTick("nextTick");
+function cancelTask(fn) {
+	const task = queueMap.get(fn);
+	if (!task) return;
+	const index = queue.indexOf(task);
+	index === -1 || queue.splice(index, 1);
+	queueMap.delete(fn);
+	task.resolve();
+}
+var effect = (raw, p) => rawToObservers.get(raw)?.forEach((observer) => isTrigger(raw, p, observer) && observerNextTick(observer));
+function runTask() {
+	const task = queue.shift();
+	if (!task) return;
+	queueMap.delete(task.fn);
+	if (task.type === "observer") {
+		unobserve(task.fn);
+		observer(task.fn);
+		task.resolve();
+	} else if (task.type === "nextTick") {
+		const result = safeCallback(task.fn);
+		result instanceof Promise ? result.finally(task.resolve) : task.resolve();
+	}
+}
+function executeAsap() {
+	while (queue.length) runTask();
+	executable = true;
+}
+function watchEffect(raw, p) {
+	const proxy = rawToProxy.get(raw);
+	if (!proxy) return;
+	const subject = proxyToSubject.get(proxy);
+	if (!subject) return;
+	const trigger = watchQueue.get(proxy);
+	if (!trigger) {
+		watchQueue.set(proxy, /* @__PURE__ */ new Set([p]));
+		nextTick(() => {
+			const trigger = watchQueue.get(proxy);
+			if (!trigger) return;
+			watchQueue.delete(proxy);
+			trigger.forEach((propName) => subject.next(propName));
+		});
+	} else if (!trigger.has(p)) trigger.add(p);
+}
+//#endregion
+export { cancelTask, effect, nextTick, watchEffect };

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

@@ -0,0 +1,58 @@
+import { TokenType } from "./tokenizer.js";
+//#region ../r-html/dist/parser/html/helper.js
+var emptyTagNamesRegexp = /^(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)$/i;
+var createEqual = (prop) => (type) => (tokens) => (pos) => tokens[pos] ? tokens[pos][prop] === type : false;
+var createTypeEqual = createEqual("type");
+var createValueEqual = createEqual("value");
+var isLtToken = createTypeEqual(TokenType.lt);
+var isGtToken = createTypeEqual(TokenType.gt);
+var isSlashToken = createTypeEqual(TokenType.slash);
+var isEqualToken = createTypeEqual(TokenType.equal);
+var isStringToken = createTypeEqual(TokenType.string);
+var isWhiteSpaceToken = createTypeEqual(TokenType.whiteSpace);
+var isStartCommentValue = createValueEqual("!--");
+var isEndCommentValue = createValueEqual("--");
+var isStartTag = (tokens) => {
+	const isLt = isLtToken(tokens);
+	const isString = isStringToken(tokens);
+	return (pos) => isLt(pos) && isString(pos + 1);
+};
+var isEndTag = (tokens) => {
+	const isLt = isLtToken(tokens);
+	const isSlash = isSlashToken(tokens);
+	const isString = isStringToken(tokens);
+	const isGt = isGtToken(tokens);
+	return (pos) => isLt(pos) && isSlash(pos + 1) && isString(pos + 2) && isGt(pos + 3);
+};
+var isSkipEndTag = (tokens) => {
+	const isLt = isLtToken(tokens);
+	const isSlash = isSlashToken(tokens);
+	const isGt = isGtToken(tokens);
+	return (pos) => isLt(pos) && isSlash(pos + 1) && isSlash(pos + 2) && isGt(pos + 3);
+};
+var isEmptyTag = (tokens) => {
+	const isSlash = isSlashToken(tokens);
+	const isGt = isGtToken(tokens);
+	return (pos) => isSlash(pos) && isGt(pos + 1);
+};
+var isEmptyTagName = (name) => emptyTagNamesRegexp.test(name);
+var isStartCommentTag = (tokens) => {
+	const isLt = isLtToken(tokens);
+	const isString = isStringToken(tokens);
+	const isStartComment = isStartCommentValue(tokens);
+	return (pos) => isLt(pos) && isString(pos + 1) && isStartComment(pos + 1);
+};
+var isEndCommentTag = (tokens) => {
+	const isString = isStringToken(tokens);
+	const isEndComment = isEndCommentValue(tokens);
+	const isGt = isGtToken(tokens);
+	return (pos) => isString(pos) && isEndComment(pos) && isGt(pos + 1);
+};
+var createAdd = (prop) => (target) => (value) => {
+	if (!value) return;
+	target[prop] ? target[prop]?.push(value) : target[prop] = [value];
+};
+var addAttr = createAdd("attrs");
+var addChild = createAdd("children");
+//#endregion
+export { addAttr, addChild, isEmptyTag, isEmptyTagName, isEndCommentTag, isEndCommentValue, isEndTag, isEqualToken, isGtToken, isLtToken, isSkipEndTag, isSlashToken, isStartCommentTag, isStartCommentValue, isStartTag, isStringToken, isWhiteSpaceToken };