@likec4/language-server 1.46.4 → 1.48.0

package/dist/_chunks/libs/ufo.mjs

@@ -0,0 +1,166 @@
+//#region ../../node_modules/.pnpm/ufo@1.6.3/node_modules/ufo/dist/index.mjs
+const r = String.fromCharCode;
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function isRelative(inputString) {
+	return ["./", "../"].some((string_) => inputString.startsWith(string_));
+}
+function hasProtocol(inputString, opts = {}) {
+	if (typeof opts === "boolean") opts = { acceptRelative: opts };
+	if (opts.strict) return PROTOCOL_STRICT_REGEX.test(inputString);
+	return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s] = path.split("?");
+	return ((s0.endsWith("/") ? s0.slice(0, -1) : s0) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function hasLeadingSlash(input = "") {
+	return input.startsWith("/");
+}
+function withoutLeadingSlash(input = "") {
+	return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
+}
+function cleanDoubleSlashes(input = "") {
+	return input.split("://").map((string_) => string_.replace(/\/{2,}/g, "/")).join("://");
+}
+function withoutBase(input, base) {
+	if (isEmptyURL(base)) return input;
+	const _base = withoutTrailingSlash(base);
+	if (!input.startsWith(_base)) return input;
+	const nextChar = input[_base.length];
+	if (nextChar && nextChar !== "/" && nextChar !== "?") return input;
+	const trimmed = input.slice(_base.length);
+	return trimmed[0] === "/" ? trimmed : "/" + trimmed;
+}
+function isEmptyURL(url) {
+	return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+function joinRelativeURL(..._input) {
+	const JOIN_SEGMENT_SPLIT_RE = /\/(?!\/)/;
+	const input = _input.filter(Boolean);
+	const segments = [];
+	let segmentsDepth = 0;
+	for (const i of input) {
+		if (!i || i === "/") continue;
+		for (const [sindex, s] of i.split(JOIN_SEGMENT_SPLIT_RE).entries()) {
+			if (!s || s === ".") continue;
+			if (s === "..") {
+				if (segments.length === 1 && hasProtocol(segments[0])) continue;
+				segments.pop();
+				segmentsDepth--;
+				continue;
+			}
+			if (sindex === 1 && segments[segments.length - 1]?.endsWith(":/")) {
+				segments[segments.length - 1] += "/" + s;
+				continue;
+			}
+			segments.push(s);
+			segmentsDepth++;
+		}
+	}
+	let url = segments.join("/");
+	if (segmentsDepth >= 0) {
+		if (input[0]?.startsWith("/") && !url.startsWith("/")) url = "/" + url;
+		else if (input[0]?.startsWith("./") && !url.startsWith("./")) url = "./" + url;
+	} else url = "../".repeat(-1 * segmentsDepth) + url;
+	if (input[input.length - 1]?.endsWith("/") && !url.endsWith("/")) url += "/";
+	return url;
+}
+function withoutProtocol(input) {
+	return withProtocol(input, "");
+}
+function withProtocol(input, protocol) {
+	let match = input.match(PROTOCOL_REGEX);
+	if (!match) match = input.match(/^\/{2,}/);
+	if (!match) return protocol + input;
+	return protocol + input.slice(match[0].length);
+}
+const protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
+	const _specialProtoMatch = input.match(/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i);
+	if (_specialProtoMatch) {
+		const [, _proto, _pathname = ""] = _specialProtoMatch;
+		return {
+			protocol: _proto.toLowerCase(),
+			pathname: _pathname,
+			href: _proto + _pathname,
+			auth: "",
+			host: "",
+			search: "",
+			hash: ""
+		};
+	}
+	if (!hasProtocol(input, { acceptRelative: true })) return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+	const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+	let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+	if (protocol === "file:") path = path.replace(/\/(?=[A-Za-z]:)/, "");
+	const { pathname, search, hash } = parsePath(path);
+	return {
+		protocol: protocol.toLowerCase(),
+		auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+		host,
+		pathname,
+		search,
+		hash,
+		[protocolRelative]: !protocol
+	};
+}
+function parsePath(input = "") {
+	const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+	return {
+		pathname,
+		search,
+		hash
+	};
+}
+const FILENAME_STRICT_REGEX = /\/([^/]+\.[^/]+)$/;
+const FILENAME_REGEX = /\/([^/]+)$/;
+function parseFilename(input = "", opts) {
+	const { pathname } = parseURL(input);
+	const matches = opts?.strict ? pathname.match(FILENAME_STRICT_REGEX) : pathname.match(FILENAME_REGEX);
+	return matches ? matches[1] : void 0;
+}
+
+//#endregion
+export { joinRelativeURL as a, withTrailingSlash as c, withoutProtocol as d, withoutTrailingSlash as f, isRelative as i, withoutBase as l, hasLeadingSlash as n, joinURL as o, hasProtocol as r, parseFilename as s, cleanDoubleSlashes as t, withoutLeadingSlash as u };

package/dist/_chunks/likec4lib.mjs

@@ -0,0 +1,9 @@
+//#region src/likec4lib.ts
+const Scheme = "likec4builtin";
+const Uri = `${Scheme}:///likec4/lib/icons.c4`;
+function isLikeC4Builtin(uri) {
+	return uri.scheme === Scheme;
+}
+
+//#endregion
+export { Uri as n, isLikeC4Builtin as r, Scheme as t };

package/dist/_chunks/mcp.mjs

@@ -0,0 +1,33 @@
+//#region src/mcp/noop.ts
+var NoopLikeC4MCPServer = class {
+	get mcp() {
+		throw new Error("NoopLikeC4MCPServer does not have a McpServer");
+	}
+	get isStarted() {
+		return false;
+	}
+	get port() {
+		return NaN;
+	}
+	start() {
+		return Promise.resolve();
+	}
+	stop() {
+		return Promise.resolve();
+	}
+};
+var NoopLikeC4MCPServerFactory = class {
+	create(_options) {
+		throw new Error("NoopLikeC4MCPServerFactory");
+	}
+};
+
+//#endregion
+//#region src/mcp/index.ts
+const NoMCPServer = {
+	mcpServer: () => new NoopLikeC4MCPServer(),
+	mcpServerFactory: () => new NoopLikeC4MCPServerFactory()
+};
+
+//#endregion
+export { NoMCPServer as t };

package/dist/_chunks/module.mjs

@@ -0,0 +1,28 @@
+import { At as LikeC4AstReflection } from "./ast.mjs";
+import { t as LikeC4Grammar } from "./grammar.mjs";
+
+//#region src/generated/module.ts
+const LikeC4LanguageMetaData = {
+	languageId: "likec4",
+	fileExtensions: [
+		".c4",
+		".likec4",
+		".like-c4"
+	],
+	caseInsensitive: false,
+	mode: "production"
+};
+const parserConfig = {
+	skipValidations: true,
+	recoveryEnabled: true,
+	nodeLocationTracking: "full"
+};
+const LikeC4GeneratedSharedModule = { AstReflection: () => new LikeC4AstReflection() };
+const LikeC4GeneratedModule = {
+	Grammar: () => LikeC4Grammar(),
+	LanguageMetaData: () => LikeC4LanguageMetaData,
+	parser: { ParserConfig: () => parserConfig }
+};
+
+//#endregion
+export { parserConfig as i, LikeC4GeneratedSharedModule as n, LikeC4LanguageMetaData as r, LikeC4GeneratedModule as t };