nuxt-ignis 0.5.1 → 0.5.3

package/.output/server/node_modules/.nitro/entities@7.0.0/dist/commonjs/internal/bin-trie-flags.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinTrieFlags = void 0;
+/**
+ * Bit flags & masks for the binary trie encoding used for entity decoding.
+ *
+ * Bit layout (16 bits total):
+ * 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
+ * 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
+ *                       If valueLength==0: compact run flag.
+ * 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
+ * 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
+ */
+var BinTrieFlags;
+(function (BinTrieFlags) {
+    BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+    BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
+    BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
+    BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (exports.BinTrieFlags = BinTrieFlags = {}));
+//# sourceMappingURL=bin-trie-flags.js.map

package/.output/server/node_modules/.nitro/entities@7.0.0/dist/commonjs/internal/decode-shared.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = decodeBase64;
+/*
+ * Shared base64 decode helper for generated decode data.
+ * Assumes global atob is available.
+ */
+function decodeBase64(input) {
+    const binary = 
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    typeof atob === "function"
+        ? // Browser (and Node >=16)
+            // eslint-disable-next-line n/no-unsupported-features/node-builtins
+            atob(input)
+        : // Older Node versions (<16)
+            // eslint-disable-next-line n/no-unsupported-features/node-builtins
+            typeof Buffer.from === "function"
+                ? // eslint-disable-next-line n/no-unsupported-features/node-builtins
+                    Buffer.from(input, "base64").toString("binary")
+                : // eslint-disable-next-line unicorn/no-new-buffer, n/no-deprecated-api
+                    new Buffer(input, "base64").toString("binary");
+    const evenLength = binary.length & ~1; // Round down to even length
+    const out = new Uint16Array(evenLength / 2);
+    for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
+        const lo = binary.charCodeAt(index);
+        const hi = binary.charCodeAt(index + 1);
+        out[outIndex++] = lo | (hi << 8);
+    }
+    return out;
+}
+//# sourceMappingURL=decode-shared.js.map

package/.output/server/node_modules/.nitro/entities@7.0.0/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/.output/server/node_modules/.nitro/entities@7.0.0/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "entities",
+  "version": "7.0.0",
+  "description": "Encode & decode XML and HTML entities with ease & speed",
+  "keywords": [
+    "html entities",
+    "entity decoder",
+    "entity encoding",
+    "html decoding",
+    "html encoding",
+    "xml decoding",
+    "xml encoding"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fb55/entities.git"
+  },
+  "funding": "https://github.com/fb55/entities?sponsor=1",
+  "license": "BSD-2-Clause",
+  "author": "Felix Boehm <me@feedic.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./decode": {
+      "import": {
+        "types": "./dist/esm/decode.d.ts",
+        "default": "./dist/esm/decode.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/decode.d.ts",
+        "default": "./dist/commonjs/decode.js"
+      }
+    },
+    "./escape": {
+      "import": {
+        "types": "./dist/esm/escape.d.ts",
+        "default": "./dist/esm/escape.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/escape.d.ts",
+        "default": "./dist/commonjs/escape.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "files": [
+    "decode.js",
+    "decode.d.ts",
+    "escape.js",
+    "escape.d.ts",
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build:docs": "typedoc --hideGenerator src/index.ts",
+    "build:encode-trie": "node --import=tsx scripts/write-encode-map.ts",
+    "build:trie": "node --import=tsx scripts/write-decode-map.ts",
+    "format": "npm run format:es && npm run format:biome",
+    "format:es": "npm run lint:es -- --fix",
+    "format:biome": "biome check --fix .",
+    "lint": "npm run lint:es && npm run lint:ts && npm run lint:biome",
+    "lint:es": "eslint . --ignore-path .gitignore",
+    "lint:biome": "biome check .",
+    "lint:ts": "tsc --noEmit",
+    "prepublishOnly": "tshy",
+    "test": "npm run test:vi && npm run lint",
+    "test:vi": "vitest run"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.2.3",
+    "@types/node": "^24.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.42.0",
+    "@typescript-eslint/parser": "^8.33.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^8.57.1",
+    "eslint-config-biome": "^2.1.3",
+    "eslint-plugin-n": "^17.21.3",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "tshy": "^3.0.2",
+    "tsx": "^4.20.5",
+    "typedoc": "^0.28.12",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=0.12"
+  },
+  "tshy": {
+    "exclude": [
+      "**/*.spec.ts",
+      "**/__fixtures__/*",
+      "**/__tests__/*",
+      "**/__snapshots__/*"
+    ],
+    "exports": {
+      ".": "./src/index.ts",
+      "./decode": "./src/decode.ts",
+      "./escape": "./src/escape.ts"
+    }
+  }
+}

package/.output/server/node_modules/@fastify/accept-negotiator/package.json

@@ -1,21 +1,17 @@
 {
   "name": "@fastify/accept-negotiator",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "description": "a negotiator for the accept-headers",
   "type": "commonjs",
   "main": "index.js",
   "types": "types/index.d.ts",
   "scripts": {
-    "lint": "standard index.js test/* benchmarks/*",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
-    "test:unit": "tap",
+    "test:unit": "c8 --100 node --test",
     "test:typescript": "tsd"
   },
-  "standard": {
-    "ignore": [
-      "index.d.ts"
-    ]
-  },
   "keywords": [
     "encoding",
     "negotiator",
@@ -30,16 +26,35 @@
     "index.js",
     "types/index.d.ts"
   ],
-  "author": "Aras Abbasi",
+  "author": "Aras Abbasi <aras.abbasi@gmail.com>",
+  "contributors": [
+    {
+      "name": "Matteo Collina",
+      "email": "hello@matteocollina.com"
+    },
+    {
+      "name": "Manuel Spigolon",
+      "email": "behemoth89@gmail.com"
+    },
+    {
+      "name": "James Sumners",
+      "url": "https://james.sumners.info"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
   "license": "MIT",
   "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "@matteo.collina/tspl": "^0.1.1",
     "benchmark": "2.1.4",
-    "standard": "17.0.0",
-    "tap": "^16.3.0",
-    "tsd": "^0.24.1"
-  },
-  "engines": {
-    "node": ">=14"
+    "c8": "^10.1.2",
+    "eslint": "^9.17.0",
+    "neostandard": "^0.12.0",
+    "tsd": "^0.31.0"
   },
   "repository": {
     "type": "git",
@@ -47,5 +62,16 @@
   },
   "bugs": {
     "url": "https://github.com/fastify/accept-negotiator/issues"
-  }
+  },
+  "homepage": "https://github.com/fastify/accept-negotiator#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ]
 }

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

@@ -0,0 +1,292 @@
+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$1 = content.split("/");
+			switch (parts$1.length) {
+				case 2:
+					alphaStr = parts$1[1].trim();
+					break;
+				case 1: break;
+				default: return null;
+			}
+			values = parts$1[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) {
+	if (color.alpha !== 1) return null;
+	let result = "";
+	const attrs = [
+		"r",
+		"g",
+		"b"
+	];
+	for (let i = 0; i < attrs.length; i++) {
+		const value = color[attrs[i]];
+		if (Math.round(value) !== value) return null;
+		const hex = value.toString(16);
+		result += (value < 16 ? "0" : "") + hex;
+	}
+	if (result.length !== 6) return null;
+	if (canCompact && result[0] === result[1] && result[2] === result[3] && result[4] === result[5]) result = result[0] + result[2] + result[4];
+	return "#" + result;
+}
+/**
+* Convert color to string
+*/
+function colorToString(color) {
+	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);
+			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 };