renovate-log-parser 0.1.0

package/web/.output/server/node_modules/@floating-ui/vue/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@floating-ui/vue",
+  "version": "1.1.11",
+  "description": "Floating UI for Vue",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.vue.umd.js",
+  "module": "./dist/floating-ui.vue.esm.js",
+  "unpkg": "./dist/floating-ui.vue.umd.min.js",
+  "types": "./dist/floating-ui.vue.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.vue.d.mts",
+        "default": "./dist/floating-ui.vue.mjs"
+      },
+      "types": "./dist/floating-ui.vue.d.ts",
+      "module": "./dist/floating-ui.vue.esm.js",
+      "default": "./dist/floating-ui.vue.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "lozinsky",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/vue"
+  },
+  "homepage": "https://floating-ui.com/docs/vue",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning",
+    "vue"
+  ],
+  "dependencies": {
+    "vue-demi": ">=0.13.0",
+    "@floating-ui/dom": "^1.7.6",
+    "@floating-ui/utils": "^0.2.11"
+  },
+  "devDependencies": {
+    "@parcel/transformer-vue": "^2.10.3",
+    "@testing-library/jest-dom": "^6.1.6",
+    "@testing-library/vue": "^6.6.1",
+    "@vitejs/plugin-vue": "^5.2.3",
+    "vue": "^3.4.4",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "clean": "rimraf dist out-tsc",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "build": "rollup -c",
+    "build:api": "build-api --tsc tsconfig.lib.json",
+    "dev": "vite",
+    "publint": "publint",
+    "typecheck": "tsc -b"
+  }
+}

package/web/.output/server/node_modules/@iconify/utils/lib/colors/index.js

@@ -0,0 +1,295 @@
+import { colorKeywords } from "./keywords.js";
+/**
+* Convert RGB to HSL
+*/
+function rgb2hsl(rgb) {
+	const c1 = rgb.r / 255, c2 = rgb.g / 255, c3 = rgb.b / 255, kmin = Math.min(c1, Math.min(c2, c3)), kmax = Math.max(c1, Math.max(c2, c3)), l = (kmax + kmin) / 2;
+	let s, h, delta;
+	if (kmax === kmin) s = h = 0;
+	else {
+		if (l < .5) s = (kmax - kmin) / (kmax + kmin);
+		else s = (kmax - kmin) / (2 - kmax - kmin);
+		delta = kmax - kmin;
+		if (kmax === c1) h = (c2 - c3) / delta;
+		else if (kmax === c2) h = 2 + (c3 - c1) / delta;
+		else h = 4 + (c1 - c2) / delta;
+		h = h * 60;
+		if (h < 0) h += 360;
+	}
+	return {
+		type: "hsl",
+		h,
+		s: s * 100,
+		l: l * 100,
+		alpha: rgb.alpha
+	};
+}
+/**
+* Color from function
+*/
+function fromFunction(value) {
+	if (value.slice(-1) !== ")") return null;
+	const parts = value.slice(0, value.length - 1).split("(");
+	if (parts.length !== 2) return null;
+	const func = parts[0].trim();
+	const content = parts[1].trim();
+	let values;
+	let alphaStr;
+	switch (func) {
+		case "lch":
+		case "lab": {
+			const parts = content.split("/");
+			switch (parts.length) {
+				case 2:
+					alphaStr = parts[1].trim();
+					break;
+				case 1: break;
+				default: return null;
+			}
+			values = parts[0].trim().split(/[\s,]+/);
+			break;
+		}
+		case "rgb":
+		case "rgba":
+		case "hsl":
+		case "hsla":
+			values = content.trim().split(/[\s,]+/);
+			if (values.length === 4) alphaStr = values.pop().trim();
+			break;
+		default: return {
+			type: "function",
+			func,
+			value: content
+		};
+	}
+	let alpha = 1;
+	if (typeof alphaStr === "string") {
+		alpha = parseFloat(alphaStr);
+		const index = alphaStr.indexOf("%");
+		const hasPercentage = index !== -1;
+		if (isNaN(alpha) || hasPercentage && index !== alphaStr.length - 1) return null;
+		if (hasPercentage) alpha /= 100;
+	}
+	if (alpha < 0 || alpha > 1 || values.length !== 3) return null;
+	if (alpha === 0) return { type: "transparent" };
+	const isPercentage = [];
+	const numbers = [];
+	for (let i = 0; i < 3; i++) {
+		const colorStr = values[i];
+		const index = colorStr.indexOf("%");
+		const hasPercentage = index !== -1;
+		if (hasPercentage && index !== colorStr.length - 1) return null;
+		const colorNum = parseFloat(colorStr);
+		if (isNaN(colorNum)) return null;
+		isPercentage.push(hasPercentage);
+		numbers.push(colorNum);
+	}
+	switch (func) {
+		case "rgb":
+		case "rgba": {
+			const hasPercengage = isPercentage[0];
+			if (hasPercengage !== isPercentage[1] || hasPercengage !== isPercentage[2]) return null;
+			let r = numbers[0];
+			let g = numbers[1];
+			let b = numbers[2];
+			if (hasPercengage) {
+				r = r * 255 / 100;
+				g = g * 255 / 100;
+				b = b * 255 / 100;
+			}
+			return {
+				type: "rgb",
+				r,
+				g,
+				b,
+				alpha
+			};
+		}
+		case "hsl":
+		case "hsla":
+			if (isPercentage[0] || !isPercentage[1] || !isPercentage[2]) return null;
+			return {
+				type: "hsl",
+				h: numbers[0],
+				s: numbers[1],
+				l: numbers[2],
+				alpha
+			};
+		case "lab":
+		case "lch":
+			if (!isPercentage[0] || isPercentage[1] || isPercentage[2]) return null;
+			return func === "lab" ? {
+				type: "lab",
+				l: numbers[0],
+				a: numbers[1],
+				b: numbers[2],
+				alpha
+			} : {
+				type: "lch",
+				l: numbers[0],
+				c: numbers[1],
+				h: numbers[2],
+				alpha
+			};
+	}
+	return null;
+}
+/**
+* From hexadecimal
+*/
+function fromHex(value) {
+	if (value.slice(0, 1) === "#") value = value.slice(1);
+	if (!/^[\da-f]+$/i.test(value)) return null;
+	let alpha = 1;
+	const hex = [
+		"",
+		"",
+		""
+	];
+	switch (value.length) {
+		case 4: alpha = parseInt(value[3] + value[3], 16) / 255;
+		case 3:
+			hex[0] = value[0] + value[0];
+			hex[1] = value[1] + value[1];
+			hex[2] = value[2] + value[2];
+			break;
+		case 8: alpha = parseInt(value[6] + value[7], 16) / 255;
+		case 6:
+			hex[0] = value[0] + value[1];
+			hex[1] = value[2] + value[3];
+			hex[2] = value[4] + value[5];
+			break;
+		default: return null;
+	}
+	return alpha === 0 ? { type: "transparent" } : {
+		type: "rgb",
+		r: parseInt(hex[0], 16),
+		g: parseInt(hex[1], 16),
+		b: parseInt(hex[2], 16),
+		alpha
+	};
+}
+/**
+* String to color
+*/
+function stringToColor(value) {
+	value = value.toLowerCase().trim();
+	if (colorKeywords[value]) return { ...colorKeywords[value] };
+	if (value.indexOf("(") !== -1) return fromFunction(value);
+	return fromHex(value);
+}
+/**
+* Check if colors are identical
+*/
+function compareColors(color1, color2) {
+	if (color1.type === color2.type) {
+		let testKeys = new Set(Object.keys(color1));
+		switch (color1.type) {
+			case "hsl":
+				if (color1.s === 0) testKeys.delete("h");
+				if (color1.l === 0 || color1.l === 100) {
+					testKeys.delete("h");
+					testKeys.delete("s");
+				}
+			case "rgb": if (color1.alpha === 0) testKeys = new Set(["a"]);
+		}
+		const keys = Array.from(testKeys);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (color1[key] !== color2[key]) return false;
+		}
+		return true;
+	}
+	const list = [color1, color2].sort((a, b) => a.type.localeCompare(b.type));
+	const item1 = list[0];
+	const item2 = list[1];
+	switch (item1.type) {
+		case "hsl":
+			switch (item2.type) {
+				case "rgb": return compareColors(item1, rgb2hsl(item2));
+				case "transparent": return item1.alpha === 0;
+			}
+			return false;
+		case "rgb": switch (item2.type) {
+			case "transparent": return item1.alpha === 0;
+		}
+	}
+	return false;
+}
+/**
+* Color to hex
+*/
+function colorToHexString(color, canCompact = true, canRound = false) {
+	let result = "";
+	let hasAlpha = false;
+	const attrs = [
+		"r",
+		"g",
+		"b"
+	];
+	if (color.alpha !== 1) {
+		attrs.push("alpha");
+		hasAlpha = true;
+	}
+	for (let i = 0; i < attrs.length; i++) {
+		const prop = attrs[i];
+		let value = Math.min(255, Math.max(0, color[prop] * (prop === "alpha" ? 255 : 1)));
+		if (canRound) value = Math.round(value);
+		else if (Math.round(value) !== value) return null;
+		const hex = value.toString(16);
+		result += (value < 16 ? "0" : "") + hex;
+	}
+	if (canCompact && result[0] === result[1] && result[2] === result[3] && result[4] === result[5] && (!hasAlpha || result[6] === result[7])) result = result[0] + result[2] + result[4] + (hasAlpha ? result[6] : "");
+	return "#" + result;
+}
+/**
+* Convert color to string
+*/
+function colorToString(color, canRound = false) {
+	if (color.alpha === 0) return "transparent";
+	switch (color.type) {
+		case "none":
+		case "transparent": return color.type;
+		case "current": return "currentColor";
+		case "rgb": {
+			const hex = colorToHexString(color, true, canRound);
+			if (hex !== null) return hex;
+			const list = [
+				color.r,
+				color.g,
+				color.b
+			];
+			if (color.alpha !== 1) list.push(color.alpha);
+			return "rgb" + (list.length === 4 ? "a(" : "(") + list.join(", ") + ")";
+		}
+		case "hsl": {
+			const list = [
+				color.h,
+				color.s.toString() + "%",
+				color.l.toString() + "%"
+			];
+			if (color.alpha !== 1) list.push(color.alpha);
+			return "hsl" + (list.length === 4 ? "a(" : "(") + list.join(", ") + ")";
+		}
+		case "lab": {
+			const list = [
+				color.l.toString() + "%",
+				color.a,
+				color.b
+			];
+			if (color.alpha !== 1) list.push("/ " + color.alpha.toString());
+			return "lab(" + list.join(" ") + ")";
+		}
+		case "lch": {
+			const list = [
+				color.l.toString() + "%",
+				color.c,
+				color.h
+			];
+			if (color.alpha !== 1) list.push("/ " + color.alpha.toString());
+			return "lch(" + list.join(" ") + ")";
+		}
+		case "function": return color.func + "(" + color.value + ")";
+	}
+}
+export { colorToHexString, colorToString, compareColors, stringToColor };