@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/libs/@ungap/structured-clone.mjs

@@ -0,0 +1,213 @@
+//#region ../../node_modules/.pnpm/@ungap+structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/types.js
+const VOID = -1;
+const PRIMITIVE = 0;
+const ARRAY = 1;
+const OBJECT = 2;
+const DATE = 3;
+const REGEXP = 4;
+const MAP = 5;
+const SET = 6;
+const ERROR = 7;
+const BIGINT = 8;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ungap+structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/deserialize.js
+const env = typeof self === "object" ? self : globalThis;
+const deserializer = ($, _) => {
+	const as = (out, index) => {
+		$.set(index, out);
+		return out;
+	};
+	const unpair = (index) => {
+		if ($.has(index)) return $.get(index);
+		const [type, value] = _[index];
+		switch (type) {
+			case PRIMITIVE:
+			case VOID: return as(value, index);
+			case ARRAY: {
+				const arr = as([], index);
+				for (const index of value) arr.push(unpair(index));
+				return arr;
+			}
+			case OBJECT: {
+				const object = as({}, index);
+				for (const [key, index] of value) object[unpair(key)] = unpair(index);
+				return object;
+			}
+			case DATE: return as(new Date(value), index);
+			case REGEXP: {
+				const { source, flags } = value;
+				return as(new RegExp(source, flags), index);
+			}
+			case MAP: {
+				const map = as(/* @__PURE__ */ new Map(), index);
+				for (const [key, index] of value) map.set(unpair(key), unpair(index));
+				return map;
+			}
+			case SET: {
+				const set = as(/* @__PURE__ */ new Set(), index);
+				for (const index of value) set.add(unpair(index));
+				return set;
+			}
+			case ERROR: {
+				const { name, message } = value;
+				return as(new env[name](message), index);
+			}
+			case BIGINT: return as(BigInt(value), index);
+			case "BigInt": return as(Object(BigInt(value)), index);
+			case "ArrayBuffer": return as(new Uint8Array(value).buffer, value);
+			case "DataView": {
+				const { buffer } = new Uint8Array(value);
+				return as(new DataView(buffer), value);
+			}
+		}
+		return as(new env[type](value), index);
+	};
+	return unpair;
+};
+/**
+* @typedef {Array<string,any>} Record a type representation
+*/
+/**
+* Returns a deserialized value from a serialized array of Records.
+* @param {Record[]} serialized a previously serialized value.
+* @returns {any}
+*/
+const deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ungap+structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/serialize.js
+const EMPTY = "";
+const { toString } = {};
+const { keys } = Object;
+const typeOf = (value) => {
+	const type = typeof value;
+	if (type !== "object" || !value) return [PRIMITIVE, type];
+	const asString = toString.call(value).slice(8, -1);
+	switch (asString) {
+		case "Array": return [ARRAY, EMPTY];
+		case "Object": return [OBJECT, EMPTY];
+		case "Date": return [DATE, EMPTY];
+		case "RegExp": return [REGEXP, EMPTY];
+		case "Map": return [MAP, EMPTY];
+		case "Set": return [SET, EMPTY];
+		case "DataView": return [ARRAY, asString];
+	}
+	if (asString.includes("Array")) return [ARRAY, asString];
+	if (asString.includes("Error")) return [ERROR, asString];
+	return [OBJECT, asString];
+};
+const shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
+const serializer = (strict, json, $, _) => {
+	const as = (out, value) => {
+		const index = _.push(out) - 1;
+		$.set(value, index);
+		return index;
+	};
+	const pair = (value) => {
+		if ($.has(value)) return $.get(value);
+		let [TYPE, type] = typeOf(value);
+		switch (TYPE) {
+			case PRIMITIVE: {
+				let entry = value;
+				switch (type) {
+					case "bigint":
+						TYPE = BIGINT;
+						entry = value.toString();
+						break;
+					case "function":
+					case "symbol":
+						if (strict) throw new TypeError("unable to serialize " + type);
+						entry = null;
+						break;
+					case "undefined": return as([VOID], value);
+				}
+				return as([TYPE, entry], value);
+			}
+			case ARRAY: {
+				if (type) {
+					let spread = value;
+					if (type === "DataView") spread = new Uint8Array(value.buffer);
+					else if (type === "ArrayBuffer") spread = new Uint8Array(value);
+					return as([type, [...spread]], value);
+				}
+				const arr = [];
+				const index = as([TYPE, arr], value);
+				for (const entry of value) arr.push(pair(entry));
+				return index;
+			}
+			case OBJECT: {
+				if (type) switch (type) {
+					case "BigInt": return as([type, value.toString()], value);
+					case "Boolean":
+					case "Number":
+					case "String": return as([type, value.valueOf()], value);
+				}
+				if (json && "toJSON" in value) return pair(value.toJSON());
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const key of keys(value)) if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]);
+				return index;
+			}
+			case DATE: return as([TYPE, value.toISOString()], value);
+			case REGEXP: {
+				const { source, flags } = value;
+				return as([TYPE, {
+					source,
+					flags
+				}], value);
+			}
+			case MAP: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const [key, entry] of value) if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]);
+				return index;
+			}
+			case SET: {
+				const entries = [];
+				const index = as([TYPE, entries], value);
+				for (const entry of value) if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry));
+				return index;
+			}
+		}
+		const { message } = value;
+		return as([TYPE, {
+			name: type,
+			message
+		}], value);
+	};
+	return pair;
+};
+/**
+* @typedef {Array<string,any>} Record a type representation
+*/
+/**
+* Returns an array of serialized Records.
+* @param {any} value a serializable value.
+* @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,
+*  if `true`, will not throw errors on incompatible types, and behave more
+*  like JSON stringify would behave. Symbol and Function will be discarded.
+* @returns {Record[]}
+*/
+const serialize = (value, { json, lossy } = {}) => {
+	const _ = [];
+	return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ungap+structured-clone@1.3.0/node_modules/@ungap/structured-clone/esm/index.js
+/**
+* @typedef {Array<string,any>} Record a type representation
+*/
+/**
+* Returns an array of serialized Records.
+* @param {any} any a serializable value.
+* @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with
+* a transfer option (ignored when polyfilled) and/or non standard fields that
+* fallback to the polyfill if present.
+* @returns {Record[]}
+*/
+var esm_default = typeof structuredClone === "function" ? (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any) : (any, options) => deserialize(serialize(any, options));
+
+//#endregion
+export { esm_default as t };

package/dist/_chunks/libs/bail.mjs

@@ -0,0 +1,14 @@
+//#region ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
+/**
+* Throw a given error.
+*
+* @param {Error|null|undefined} [error]
+*   Maybe error.
+* @returns {asserts error is null|undefined}
+*/
+function bail(error) {
+	if (error) throw error;
+}
+
+//#endregion
+export { bail as t };

package/dist/_chunks/libs/ccount.mjs

@@ -0,0 +1,25 @@
+//#region ../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js
+/**
+* Count how often a character (or substring) is used in a string.
+*
+* @param {string} value
+*   Value to search in.
+* @param {string} character
+*   Character (or substring) to look for.
+* @return {number}
+*   Number of times `character` occurred in `value`.
+*/
+function ccount(value, character) {
+	const source = String(value);
+	if (typeof character !== "string") throw new TypeError("Expected character");
+	let count = 0;
+	let index = source.indexOf(character);
+	while (index !== -1) {
+		count++;
+		index = source.indexOf(character, index + character.length);
+	}
+	return count;
+}
+
+//#endregion
+export { ccount as t };

package/dist/_chunks/libs/character-entities-html4.mjs

@@ -0,0 +1,263 @@
+//#region ../../node_modules/.pnpm/character-entities-html4@2.1.0/node_modules/character-entities-html4/index.js
+/**
+* Map of named character references from HTML 4.
+*
+* @type {Record<string, string>}
+*/
+const characterEntitiesHtml4 = {
+	nbsp: "\xA0",
+	iexcl: "¡",
+	cent: "¢",
+	pound: "£",
+	curren: "¤",
+	yen: "¥",
+	brvbar: "¦",
+	sect: "§",
+	uml: "¨",
+	copy: "©",
+	ordf: "ª",
+	laquo: "«",
+	not: "¬",
+	shy: "­",
+	reg: "®",
+	macr: "¯",
+	deg: "°",
+	plusmn: "±",
+	sup2: "²",
+	sup3: "³",
+	acute: "´",
+	micro: "µ",
+	para: "¶",
+	middot: "·",
+	cedil: "¸",
+	sup1: "¹",
+	ordm: "º",
+	raquo: "»",
+	frac14: "¼",
+	frac12: "½",
+	frac34: "¾",
+	iquest: "¿",
+	Agrave: "À",
+	Aacute: "Á",
+	Acirc: "Â",
+	Atilde: "Ã",
+	Auml: "Ä",
+	Aring: "Å",
+	AElig: "Æ",
+	Ccedil: "Ç",
+	Egrave: "È",
+	Eacute: "É",
+	Ecirc: "Ê",
+	Euml: "Ë",
+	Igrave: "Ì",
+	Iacute: "Í",
+	Icirc: "Î",
+	Iuml: "Ï",
+	ETH: "Ð",
+	Ntilde: "Ñ",
+	Ograve: "Ò",
+	Oacute: "Ó",
+	Ocirc: "Ô",
+	Otilde: "Õ",
+	Ouml: "Ö",
+	times: "×",
+	Oslash: "Ø",
+	Ugrave: "Ù",
+	Uacute: "Ú",
+	Ucirc: "Û",
+	Uuml: "Ü",
+	Yacute: "Ý",
+	THORN: "Þ",
+	szlig: "ß",
+	agrave: "à",
+	aacute: "á",
+	acirc: "â",
+	atilde: "ã",
+	auml: "ä",
+	aring: "å",
+	aelig: "æ",
+	ccedil: "ç",
+	egrave: "è",
+	eacute: "é",
+	ecirc: "ê",
+	euml: "ë",
+	igrave: "ì",
+	iacute: "í",
+	icirc: "î",
+	iuml: "ï",
+	eth: "ð",
+	ntilde: "ñ",
+	ograve: "ò",
+	oacute: "ó",
+	ocirc: "ô",
+	otilde: "õ",
+	ouml: "ö",
+	divide: "÷",
+	oslash: "ø",
+	ugrave: "ù",
+	uacute: "ú",
+	ucirc: "û",
+	uuml: "ü",
+	yacute: "ý",
+	thorn: "þ",
+	yuml: "ÿ",
+	fnof: "ƒ",
+	Alpha: "Α",
+	Beta: "Β",
+	Gamma: "Γ",
+	Delta: "Δ",
+	Epsilon: "Ε",
+	Zeta: "Ζ",
+	Eta: "Η",
+	Theta: "Θ",
+	Iota: "Ι",
+	Kappa: "Κ",
+	Lambda: "Λ",
+	Mu: "Μ",
+	Nu: "Ν",
+	Xi: "Ξ",
+	Omicron: "Ο",
+	Pi: "Π",
+	Rho: "Ρ",
+	Sigma: "Σ",
+	Tau: "Τ",
+	Upsilon: "Υ",
+	Phi: "Φ",
+	Chi: "Χ",
+	Psi: "Ψ",
+	Omega: "Ω",
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ε",
+	zeta: "ζ",
+	eta: "η",
+	theta: "θ",
+	iota: "ι",
+	kappa: "κ",
+	lambda: "λ",
+	mu: "μ",
+	nu: "ν",
+	xi: "ξ",
+	omicron: "ο",
+	pi: "π",
+	rho: "ρ",
+	sigmaf: "ς",
+	sigma: "σ",
+	tau: "τ",
+	upsilon: "υ",
+	phi: "φ",
+	chi: "χ",
+	psi: "ψ",
+	omega: "ω",
+	thetasym: "ϑ",
+	upsih: "ϒ",
+	piv: "ϖ",
+	bull: "•",
+	hellip: "…",
+	prime: "′",
+	Prime: "″",
+	oline: "‾",
+	frasl: "⁄",
+	weierp: "℘",
+	image: "ℑ",
+	real: "ℜ",
+	trade: "™",
+	alefsym: "ℵ",
+	larr: "←",
+	uarr: "↑",
+	rarr: "→",
+	darr: "↓",
+	harr: "↔",
+	crarr: "↵",
+	lArr: "⇐",
+	uArr: "⇑",
+	rArr: "⇒",
+	dArr: "⇓",
+	hArr: "⇔",
+	forall: "∀",
+	part: "∂",
+	exist: "∃",
+	empty: "∅",
+	nabla: "∇",
+	isin: "∈",
+	notin: "∉",
+	ni: "∋",
+	prod: "∏",
+	sum: "∑",
+	minus: "−",
+	lowast: "∗",
+	radic: "√",
+	prop: "∝",
+	infin: "∞",
+	ang: "∠",
+	and: "∧",
+	or: "∨",
+	cap: "∩",
+	cup: "∪",
+	int: "∫",
+	there4: "∴",
+	sim: "∼",
+	cong: "≅",
+	asymp: "≈",
+	ne: "≠",
+	equiv: "≡",
+	le: "≤",
+	ge: "≥",
+	sub: "⊂",
+	sup: "⊃",
+	nsub: "⊄",
+	sube: "⊆",
+	supe: "⊇",
+	oplus: "⊕",
+	otimes: "⊗",
+	perp: "⊥",
+	sdot: "⋅",
+	lceil: "⌈",
+	rceil: "⌉",
+	lfloor: "⌊",
+	rfloor: "⌋",
+	lang: "〈",
+	rang: "〉",
+	loz: "◊",
+	spades: "♠",
+	clubs: "♣",
+	hearts: "♥",
+	diams: "♦",
+	quot: "\"",
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	OElig: "Œ",
+	oelig: "œ",
+	Scaron: "Š",
+	scaron: "š",
+	Yuml: "Ÿ",
+	circ: "ˆ",
+	tilde: "˜",
+	ensp: " ",
+	emsp: " ",
+	thinsp: " ",
+	zwnj: "‌",
+	zwj: "‍",
+	lrm: "‎",
+	rlm: "‏",
+	ndash: "–",
+	mdash: "—",
+	lsquo: "‘",
+	rsquo: "’",
+	sbquo: "‚",
+	ldquo: "“",
+	rdquo: "”",
+	bdquo: "„",
+	dagger: "†",
+	Dagger: "‡",
+	permil: "‰",
+	lsaquo: "‹",
+	rsaquo: "›",
+	euro: "€"
+};
+
+//#endregion
+export { characterEntitiesHtml4 as t };

package/dist/_chunks/libs/character-entities-legacy.mjs

@@ -0,0 +1,117 @@
+//#region ../../node_modules/.pnpm/character-entities-legacy@3.0.0/node_modules/character-entities-legacy/index.js
+/**
+* List of legacy HTML named character references that don’t need a trailing semicolon.
+*
+* @type {Array<string>}
+*/
+const characterEntitiesLegacy = [
+	"AElig",
+	"AMP",
+	"Aacute",
+	"Acirc",
+	"Agrave",
+	"Aring",
+	"Atilde",
+	"Auml",
+	"COPY",
+	"Ccedil",
+	"ETH",
+	"Eacute",
+	"Ecirc",
+	"Egrave",
+	"Euml",
+	"GT",
+	"Iacute",
+	"Icirc",
+	"Igrave",
+	"Iuml",
+	"LT",
+	"Ntilde",
+	"Oacute",
+	"Ocirc",
+	"Ograve",
+	"Oslash",
+	"Otilde",
+	"Ouml",
+	"QUOT",
+	"REG",
+	"THORN",
+	"Uacute",
+	"Ucirc",
+	"Ugrave",
+	"Uuml",
+	"Yacute",
+	"aacute",
+	"acirc",
+	"acute",
+	"aelig",
+	"agrave",
+	"amp",
+	"aring",
+	"atilde",
+	"auml",
+	"brvbar",
+	"ccedil",
+	"cedil",
+	"cent",
+	"copy",
+	"curren",
+	"deg",
+	"divide",
+	"eacute",
+	"ecirc",
+	"egrave",
+	"eth",
+	"euml",
+	"frac12",
+	"frac14",
+	"frac34",
+	"gt",
+	"iacute",
+	"icirc",
+	"iexcl",
+	"igrave",
+	"iquest",
+	"iuml",
+	"laquo",
+	"lt",
+	"macr",
+	"micro",
+	"middot",
+	"nbsp",
+	"not",
+	"ntilde",
+	"oacute",
+	"ocirc",
+	"ograve",
+	"ordf",
+	"ordm",
+	"oslash",
+	"otilde",
+	"ouml",
+	"para",
+	"plusmn",
+	"pound",
+	"quot",
+	"raquo",
+	"reg",
+	"sect",
+	"shy",
+	"sup1",
+	"sup2",
+	"sup3",
+	"szlig",
+	"thorn",
+	"times",
+	"uacute",
+	"ucirc",
+	"ugrave",
+	"uml",
+	"uuml",
+	"yacute",
+	"yen",
+	"yuml"
+];
+
+//#endregion
+export { characterEntitiesLegacy as t };