@codefast/cli 0.3.13-canary.2 → 0.3.13-canary.4

package/dist/lib/arrange/domain/tokenizer.util.mjs

@@ -0,0 +1,209 @@
+import { COMPATIBLE_BUCKET_SETS, RESPONSIVE_PREFIX, STATE_PREFIXES } from "./constants.domain.mjs";
+//#region src/lib/arrange/domain/tokenizer.util.ts
+/**
+* Bare-token classification is **total** (always returns a {@link Bucket}). The `Result` pattern
+* (`isOk` / `isErr`) belongs at arrange use-case / I/O boundaries, not on this hot path.
+*
+* Variant stems not covered by a single entry in STATE_PREFIXES (compound `has-*`,
+* numbered `nth-*`, media features, v4 `in-[…]`, child selectors `*` / `**`, …).
+* When these are missed, `isStateToken` is false and the variant is stripped — the
+* utility is then bucketed as if it were unconditional, which breaks preview grouping.
+*/ function isCompoundOrMediaVariantPrefix(prefix) {
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix === "inert") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (/^nth(?:-last)?(?:-of-type)?(?:-\d+|-\[)/.test(prefix) || /^nth-of-type-\d+$/.test(prefix) || /^nth-last-of-type-\d+$/.test(prefix)) return true;
+	if (/^(?:user-valid|user-invalid|contrast-more|contrast-less|forced-colors|inverted-colors)$/.test(prefix)) return true;
+	if (/^(?:any-)?pointer-(?:fine|coarse|none)$/.test(prefix)) return true;
+	if (/^(?:portrait|landscape|noscript)$/.test(prefix)) return true;
+	return false;
+}
+function tokenizeClassString(classString) {
+	return classString.trim().split(/\s+/).filter(Boolean);
+}
+/**
+* Index of the first `:` that separates a Tailwind variant segment from the rest.
+* Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
+* `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
+*/ function indexOfFirstVariantColon(text) {
+	let depth = 0;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "[") depth++;
+		else if (ch === "]") depth = Math.max(0, depth - 1);
+		else if (ch === ":" && depth === 0) return i;
+	}
+	return -1;
+}
+function stripVariants(token) {
+	let withoutVariants = token;
+	const MAX_PASSES = 12;
+	for (let i = 0; i < MAX_PASSES; i++) {
+		const colonIdx = indexOfFirstVariantColon(withoutVariants);
+		if (colonIdx === -1) break;
+		withoutVariants = withoutVariants.slice(colonIdx + 1);
+	}
+	return withoutVariants;
+}
+/** Outermost variant segment: first `:` at bracket depth 0 → text before it. */ function firstLeadingVariantPrefix(token) {
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1) return;
+	return token.slice(0, colonIdx);
+}
+function isSelectorVariantToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (prefix.startsWith("group-[")) return true;
+	if (prefix.startsWith("peer-[")) return true;
+	if (prefix.startsWith("not-[")) return true;
+	return false;
+}
+function isStateToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (RESPONSIVE_PREFIX.test(token)) return true;
+	if (STATE_PREFIXES.has(prefix)) return true;
+	if (prefix.startsWith("data-[")) return true;
+	if (prefix.startsWith("aria-[")) return true;
+	if (prefix.startsWith("supports-[")) return true;
+	if (prefix.startsWith("in-data-")) return true;
+	if (/^data-(?!\[)/.test(prefix)) return true;
+	if (/^aria-/.test(prefix)) return true;
+	if (/^(group|peer)-/.test(prefix)) return true;
+	if (/^not-/.test(prefix)) return true;
+	if (isCompoundOrMediaVariantPrefix(prefix)) return true;
+	if (prefix.startsWith("[") && prefix.endsWith("]")) return true;
+	return false;
+}
+/**
+* Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+* 3D context → 3D transforms → 2D transforms → filters → will-change.
+*/ function compositeSecondaryOrder(bareUtility) {
+	const b = bareUtility;
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate") return 0;
+	if (b === "transform-3d" || /^perspective(?:-|$)/.test(b)) return 10;
+	if (/^rotate-[xyz](?:-|$)/.test(b) || /^translate-z(?:-|$)/.test(b) || /^scale-z(?:-|$)/.test(b)) return 20;
+	if (/^translate(?:-|$)/.test(b) || /^scale(?:-|$)/.test(b) || /^rotate(?:-|$)/.test(b) || /^skew(?:-|$)/.test(b)) return 30;
+	if (/^transform(?:-(?:gpu|cpu|none))?$/.test(b)) return 35;
+	if (/^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b)) return 40;
+	if (/^will-change/.test(b)) return 50;
+	return 99;
+}
+/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */ function classifyBareUtility(bareUtility) {
+	const b = bareUtility;
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(b)) return "existence";
+	if (/^(?:hidden|contents|sr-only|not-sr-only|list-item|flow-root)$/.test(b) || /^(?:block|inline-block|inline)$/.test(b)) return "existence";
+	if (/^table(?:$|-)/.test(b)) return "existence";
+	if (/^contain-/.test(b)) return "existence";
+	if (/^(?:group|peer)(?:\/[a-z][a-z0-9-]*)?$/.test(b)) return "existence";
+	if (/^(?:static|relative|absolute|fixed|sticky)$/.test(b)) return "position";
+	if (/^-?(?:inset|top|right|bottom|left|start|end)(?:-|\/|$)/.test(b) || /^-?(?:inset-x|inset-y|inset-s|inset-e)-/.test(b)) return "position";
+	if (/^-?z-/.test(b) || b === "z-auto") return "position";
+	if (/^(?:flex|inline-flex|grid|inline-grid|subgrid|masonry)(?:$|-)/.test(b) || /^(?:items|justify|justify-items|justify-self|content|self|place|place-content|place-items|place-self)-/.test(b) || /^-?(?:gap|space-[xy]|col-|row-|grid-|auto-cols|auto-rows|order-|order$)/.test(b) || /^-?(?:auto-flow|grid-flow)-/.test(b) || /^(?:columns-|break-after|break-before|break-inside)-/.test(b) || /^(?:float|clear)-/.test(b) || /^(?:wrap-|flex-wrap|flex-nowrap|flex-row|flex-col|flex-auto|flex-initial|flex-none|flex-1|flex-\[)/.test(b) || /^container$/.test(b)) return "layout";
+	if (/^-?(?:w|h|min-w|max-w|min-h|max-h|size|aspect|shrink|grow|basis)-/.test(b) || /^(?:shrink|grow)(?:$|-)/.test(b) || /^-?overflow-/.test(b) || /^-?object-/.test(b)) return "sizing";
+	if (/^-?(?:p|px|py|pt|pb|pl|pr|ps|pe|m|mx|my|mt|mb|ml|mr|ms|me)-/.test(b)) return "spacing";
+	if (/^-?(?:rounded|border|ring|divide|inset-ring)(?:-|\/|$)/.test(b) || /^(?:rounded|border|ring|divide|inset-ring)$/.test(b) || /^ring-offset-/.test(b)) return "shape";
+	if (/^-?bg-/.test(b) || /^(?:from|via|to)(?:-|\/|$)/.test(b) || /^bg-(?:linear|radial|conic)-/.test(b) || /^-?mask-/.test(b) || /^-?(?:fill|stroke)-/.test(b)) return "background";
+	if (/^-?(?:shadow|inset-shadow|drop-shadow|text-shadow)(?:-|\/|$)/.test(b) || /^(?:shadow|inset-shadow)$/.test(b) || /^-?outline(?:-|\/|$)/.test(b) || /^outline$/.test(b)) return "shadow";
+	if (/^-?(?:font|leading|tracking|list|indent|align|decoration|underline-offset|text-wrap|text-balance|text-pretty)-/.test(b) || /^-?(?:text-(?!shadow))/.test(b) || /^-?(?:whitespace|break|line-clamp|hyphens)-/.test(b) || /^(?:antialiased|subpixel-antialiased|italic|not-italic|overline|line-through|underline|no-underline|uppercase|lowercase|capitalize|normal-case|truncate|text-wrap|text-balance|text-pretty)$/.test(b) || /^text-wrap-/.test(b) || /^tabular-nums$|^slashed-zero$|^lining-nums$|^oldstyle-nums$|^proportional-nums$/.test(b)) return "typography";
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate" || /^transform(?:-(?:gpu|cpu|none))?$/.test(b) || /^-?(?:translate|scale|rotate|skew)-/.test(b) || /^perspective(?:-|$)/.test(b) || b === "transform-3d" || /^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b) || /^will-change/.test(b)) return "composite";
+	if (/^(?:transition|duration|ease|delay|animate)(?:-|$)/.test(b) || /^ease-/.test(b)) return "motion";
+	if (/^(?:cursor|pointer-events|select|touch|scroll|scroll-m|scroll-p|overscroll|snap|resize|field-sizing|appearance|scheme|color-scheme|accent|caret)(?:-|$)/.test(b) || /^(?:cursor|select|resize)$/.test(b) || /^scroll-behavior/.test(b) || /^scroll-snap/.test(b) || /^touch-action/.test(b) || b === "inert") return "behavior";
+	return "other";
+}
+/**
+* Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
+* scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
+* and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
+* Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
+*/ function isArbitraryParentSelectorStateToken(token) {
+	if (/^\[&/.test(token)) return true;
+	if (!token.startsWith("[")) return false;
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1 || colonIdx === 0 || token[colonIdx - 1] !== "]") return false;
+	return token.slice(0, colonIdx).includes("&");
+}
+function classifyToken(token) {
+	if (isArbitraryParentSelectorStateToken(token)) return "selector";
+	if (isSelectorVariantToken(token)) return "selector";
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(token)) return "existence";
+	if (token.startsWith("[")) {
+		const splitIdx = indexOfFirstVariantColon(token);
+		if (splitIdx === -1) return "arbitrary";
+		if (splitIdx === 0 || token[splitIdx - 1] !== "]") return "arbitrary";
+	}
+	if (firstLeadingVariantPrefix(token) === "starting") return "starting";
+	if (isStateToken(token)) return "state";
+	return classifyBareUtility(stripVariants(token));
+}
+/**
+* Stable key for `data-[…]` variants so unrelated selectors stay split, while
+* **branching on the full bracket** (e.g. `data-[vaul-drawer-direction=bottom]`
+* vs `=left`) keeps direction-specific utilities in separate state groups.
+*/ function dataAttributeStem(token) {
+	const match = token.match(/^data-\[([^\]]*)\]/);
+	return match ? `data-[${match[1]}]` : "data";
+}
+/** Same idea as {@link dataAttributeStem} for `aria-[…]:` variants. */ function ariaAttributeStem(token) {
+	const match = token.match(/^aria-\[([^\]]*)\]/);
+	return match ? `aria-[${match[1]}]` : "aria";
+}
+/** `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}. */ function inDataAttributeStem(token) {
+	const match = token.match(/^in-data-\[([^\]]*)\]/);
+	return match ? `in-data-[${match[1]}]` : "in-data";
+}
+/**
+* Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
+* (`selector` uses {@link selectorKey}).
+* Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
+* outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
+* separate groups while `hover:opacity` still keys as `hover` + `opacity`…
+*
+* `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
+* {@link ariaAttributeStem} (full token required for bracket capture).
+*/ function stateKey(token) {
+	const layers = [];
+	let rest = token;
+	while (rest.length > 0) {
+		const colonIdx = indexOfFirstVariantColon(rest);
+		if (colonIdx === -1) break;
+		layers.push(rest.slice(0, colonIdx));
+		rest = rest.slice(colonIdx + 1);
+	}
+	if (layers.length === 0) return token;
+	const firstLayer = layers[0];
+	if (firstLayer === void 0) return token;
+	if (firstLayer.startsWith("data-[")) layers[0] = dataAttributeStem(token);
+	else if (firstLayer.startsWith("aria-[")) layers[0] = ariaAttributeStem(token);
+	else if (firstLayer.startsWith("in-data-[")) layers[0] = inDataAttributeStem(token);
+	return layers.join("");
+}
+const SELECTOR_KEY_SEP = "";
+/**
+* Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+* Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
+* `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+*/ function selectorKey(token) {
+	return stateKey(token).split(SELECTOR_KEY_SEP).map(normalizeSelectorVariantLayer).join(SELECTOR_KEY_SEP);
+}
+function normalizeSelectorVariantLayer(layer) {
+	if (layer === "[&_svg:not([class*='size-'])]") return "[&_svg]";
+	return layer;
+}
+function bucketsCompatible(a, b) {
+	if (a === b) return true;
+	return COMPATIBLE_BUCKET_SETS.some((bucketSet) => bucketSet.has(a) && bucketSet.has(b));
+}
+/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */ function bucketsMergeCompatible(a, b) {
+	if (a === "state" && b === "state") return false;
+	if (a === "starting" && b === "starting") return false;
+	if (a === "selector" && b === "selector") return false;
+	if (a === "arbitrary" || b === "arbitrary") return false;
+	return bucketsCompatible(a, b);
+}
+//#endregion
+export { bucketsCompatible, bucketsMergeCompatible, classifyBareUtility, classifyToken, compositeSecondaryOrder, indexOfFirstVariantColon, isArbitraryParentSelectorStateToken, selectorKey, stateKey, stripVariants, tokenizeClassString };

package/dist/lib/arrange/infra/domain-source-parser.adapter.mjs

@@ -0,0 +1,240 @@
+import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
+import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
+import { parseDomainSourceFile } from "./ts-ast-translator.adapter.mjs";
+import { inject, injectable } from "@codefast/di";
+//#region src/lib/arrange/infra/domain-source-parser.adapter.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+_dec = injectable([inject(CliLoggerToken)]);
+let _DomainSourceParserAdapter;
+(class {
+	logger;
+	static {
+		({c: [_DomainSourceParserAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(logger) {
+		this.logger = logger;
+	}
+	parseDomainSourceFile(filePath, sourceText) {
+		try {
+			return parseDomainSourceFile(filePath, sourceText);
+		} catch (caughtError) {
+			this.logger?.err(`[domain-source-parser] ${messageFromCaughtUnknown(caughtError)}`);
+			throw caughtError;
+		}
+	}
+	static {
+		_initClass();
+	}
+});
+/** Default instance without diagnostics logging (tests and legacy imports). */ const domainSourceParserAdapter = new _DomainSourceParserAdapter();
+//#endregion
+export { _DomainSourceParserAdapter as DomainSourceParserAdapter, domainSourceParserAdapter };

package/dist/lib/arrange/infra/ensure-cn-import.adapter.mjs

@@ -0,0 +1,8 @@
+import { ensureCnImport as ensureCnImport$1 } from "../domain/imports.domain.mjs";
+import { parseDomainSourceFile } from "./ts-ast-translator.adapter.mjs";
+//#region src/lib/arrange/infra/ensure-cn-import.adapter.ts
+/** Parses source then applies domain cn import injection rules (public CLI-style entry). */ function ensureCnImport(sourceText, filePath, cnImportOverride) {
+	return ensureCnImport$1(parseDomainSourceFile(filePath, sourceText), cnImportOverride);
+}
+//#endregion
+export { ensureCnImport };