@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/libs/is-plain-obj.mjs

@@ -0,0 +1,9 @@
+//#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+//#endregion
+export { isPlainObject as t };

package/dist/_chunks/libs/longest-streak.mjs

@@ -0,0 +1,30 @@
+//#region ../../node_modules/.pnpm/longest-streak@3.1.0/node_modules/longest-streak/index.js
+/**
+* Get the count of the longest repeating streak of `substring` in `value`.
+*
+* @param {string} value
+*   Content to search in.
+* @param {string} substring
+*   Substring to look for, typically one character.
+* @returns {number}
+*   Count of most frequent adjacent `substring`s in `value`.
+*/
+function longestStreak(value, substring) {
+	const source = String(value);
+	let index = source.indexOf(substring);
+	let expected = index;
+	let count = 0;
+	let max = 0;
+	if (typeof substring !== "string") throw new TypeError("Expected substring");
+	while (index !== -1) {
+		if (index === expected) {
+			if (++count > max) max = count;
+		} else count = 1;
+		expected = index + substring.length;
+		index = source.indexOf(substring, expected);
+	}
+	return max;
+}
+
+//#endregion
+export { longestStreak as t };

package/dist/_chunks/libs/markdown-table.mjs

@@ -0,0 +1,290 @@
+//#region ../../node_modules/.pnpm/markdown-table@3.0.4/node_modules/markdown-table/index.js
+/**
+* @typedef {Options} MarkdownTableOptions
+*   Configuration.
+*/
+/**
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [alignDelimiters=true]
+*   Whether to align the delimiters (default: `true`);
+*   they are aligned by default:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   Pass `false` to make them staggered:
+*
+*   ```markdown
+*   | Alpha | B |
+*   | - | - |
+*   | C | Delta |
+*   ```
+* @property {ReadonlyArray<string | null | undefined> | string | null | undefined} [align]
+*   How to align columns (default: `''`);
+*   one style for all columns or styles for their respective columns;
+*   each style is either `'l'` (left), `'r'` (right), or `'c'` (center);
+*   other values are treated as `''`, which doesn’t place the colon in the
+*   alignment row but does align left;
+*   *only the lowercased first character is used, so `Right` is fine.*
+* @property {boolean | null | undefined} [delimiterEnd=true]
+*   Whether to end each row with the delimiter (default: `true`).
+*
+*   > 👉 **Note**: please don’t use this: it could create fragile structures
+*   > that aren’t understandable to some markdown parsers.
+*
+*   When `true`, there are ending delimiters:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there are no ending delimiters:
+*
+*   ```markdown
+*   | Alpha | B
+*   | ----- | -----
+*   | C     | Delta
+*   ```
+* @property {boolean | null | undefined} [delimiterStart=true]
+*   Whether to begin each row with the delimiter (default: `true`).
+*
+*   > 👉 **Note**: please don’t use this: it could create fragile structures
+*   > that aren’t understandable to some markdown parsers.
+*
+*   When `true`, there are starting delimiters:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there are no starting delimiters:
+*
+*   ```markdown
+*   Alpha | B     |
+*   ----- | ----- |
+*   C     | Delta |
+*   ```
+* @property {boolean | null | undefined} [padding=true]
+*   Whether to add a space of padding between delimiters and cells
+*   (default: `true`).
+*
+*   When `true`, there is padding:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there is no padding:
+*
+*   ```markdown
+*   |Alpha|B    |
+*   |-----|-----|
+*   |C    |Delta|
+*   ```
+* @property {((value: string) => number) | null | undefined} [stringLength]
+*   Function to detect the length of table cell content (optional);
+*   this is used when aligning the delimiters (`|`) between table cells;
+*   full-width characters and emoji mess up delimiter alignment when viewing
+*   the markdown source;
+*   to fix this, you can pass this function,
+*   which receives the cell content and returns its “visible” size;
+*   note that what is and isn’t visible depends on where the text is displayed.
+*
+*   Without such a function, the following:
+*
+*   ```js
+*   markdownTable([
+*     ['Alpha', 'Bravo'],
+*     ['中文', 'Charlie'],
+*     ['👩‍❤️‍👩', 'Delta']
+*   ])
+*   ```
+*
+*   Yields:
+*
+*   ```markdown
+*   | Alpha | Bravo |
+*   | - | - |
+*   | 中文 | Charlie |
+*   | 👩‍❤️‍👩 | Delta |
+*   ```
+*
+*   With [`string-width`](https://github.com/sindresorhus/string-width):
+*
+*   ```js
+*   import stringWidth from 'string-width'
+*
+*   markdownTable(
+*     [
+*       ['Alpha', 'Bravo'],
+*       ['中文', 'Charlie'],
+*       ['👩‍❤️‍👩', 'Delta']
+*     ],
+*     {stringLength: stringWidth}
+*   )
+*   ```
+*
+*   Yields:
+*
+*   ```markdown
+*   | Alpha | Bravo   |
+*   | ----- | ------- |
+*   | 中文  | Charlie |
+*   | 👩‍❤️‍👩    | Delta   |
+*   ```
+*/
+/**
+* @param {string} value
+*   Cell value.
+* @returns {number}
+*   Cell size.
+*/
+function defaultStringLength(value) {
+	return value.length;
+}
+/**
+* Generate a markdown
+* ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables))
+* table.
+*
+* @param {ReadonlyArray<ReadonlyArray<string | null | undefined>>} table
+*   Table data (matrix of strings).
+* @param {Readonly<Options> | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Result.
+*/
+function markdownTable(table, options) {
+	const settings = options || {};
+	const align = (settings.align || []).concat();
+	const stringLength = settings.stringLength || defaultStringLength;
+	/** @type {Array<number>} Character codes as symbols for alignment per column. */
+	const alignments = [];
+	/** @type {Array<Array<string>>} Cells per row. */
+	const cellMatrix = [];
+	/** @type {Array<Array<number>>} Sizes of each cell per row. */
+	const sizeMatrix = [];
+	/** @type {Array<number>} */
+	const longestCellByColumn = [];
+	let mostCellsPerRow = 0;
+	let rowIndex = -1;
+	while (++rowIndex < table.length) {
+		/** @type {Array<string>} */
+		const row = [];
+		/** @type {Array<number>} */
+		const sizes = [];
+		let columnIndex = -1;
+		if (table[rowIndex].length > mostCellsPerRow) mostCellsPerRow = table[rowIndex].length;
+		while (++columnIndex < table[rowIndex].length) {
+			const cell = serialize(table[rowIndex][columnIndex]);
+			if (settings.alignDelimiters !== false) {
+				const size = stringLength(cell);
+				sizes[columnIndex] = size;
+				if (longestCellByColumn[columnIndex] === void 0 || size > longestCellByColumn[columnIndex]) longestCellByColumn[columnIndex] = size;
+			}
+			row.push(cell);
+		}
+		cellMatrix[rowIndex] = row;
+		sizeMatrix[rowIndex] = sizes;
+	}
+	let columnIndex = -1;
+	if (typeof align === "object" && "length" in align) while (++columnIndex < mostCellsPerRow) alignments[columnIndex] = toAlignment(align[columnIndex]);
+	else {
+		const code = toAlignment(align);
+		while (++columnIndex < mostCellsPerRow) alignments[columnIndex] = code;
+	}
+	columnIndex = -1;
+	/** @type {Array<string>} */
+	const row = [];
+	/** @type {Array<number>} */
+	const sizes = [];
+	while (++columnIndex < mostCellsPerRow) {
+		const code = alignments[columnIndex];
+		let before = "";
+		let after = "";
+		if (code === 99) {
+			before = ":";
+			after = ":";
+		} else if (code === 108) before = ":";
+		else if (code === 114) after = ":";
+		let size = settings.alignDelimiters === false ? 1 : Math.max(1, longestCellByColumn[columnIndex] - before.length - after.length);
+		const cell = before + "-".repeat(size) + after;
+		if (settings.alignDelimiters !== false) {
+			size = before.length + size + after.length;
+			if (size > longestCellByColumn[columnIndex]) longestCellByColumn[columnIndex] = size;
+			sizes[columnIndex] = size;
+		}
+		row[columnIndex] = cell;
+	}
+	cellMatrix.splice(1, 0, row);
+	sizeMatrix.splice(1, 0, sizes);
+	rowIndex = -1;
+	/** @type {Array<string>} */
+	const lines = [];
+	while (++rowIndex < cellMatrix.length) {
+		const row = cellMatrix[rowIndex];
+		const sizes = sizeMatrix[rowIndex];
+		columnIndex = -1;
+		/** @type {Array<string>} */
+		const line = [];
+		while (++columnIndex < mostCellsPerRow) {
+			const cell = row[columnIndex] || "";
+			let before = "";
+			let after = "";
+			if (settings.alignDelimiters !== false) {
+				const size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
+				const code = alignments[columnIndex];
+				if (code === 114) before = " ".repeat(size);
+				else if (code === 99) if (size % 2) {
+					before = " ".repeat(size / 2 + .5);
+					after = " ".repeat(size / 2 - .5);
+				} else {
+					before = " ".repeat(size / 2);
+					after = before;
+				}
+				else after = " ".repeat(size);
+			}
+			if (settings.delimiterStart !== false && !columnIndex) line.push("|");
+			if (settings.padding !== false && !(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) line.push(" ");
+			if (settings.alignDelimiters !== false) line.push(before);
+			line.push(cell);
+			if (settings.alignDelimiters !== false) line.push(after);
+			if (settings.padding !== false) line.push(" ");
+			if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) line.push("|");
+		}
+		lines.push(settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join(""));
+	}
+	return lines.join("\n");
+}
+/**
+* @param {string | null | undefined} [value]
+*   Value to serialize.
+* @returns {string}
+*   Result.
+*/
+function serialize(value) {
+	return value === null || value === void 0 ? "" : String(value);
+}
+/**
+* @param {string | null | undefined} value
+*   Value.
+* @returns {number}
+*   Alignment.
+*/
+function toAlignment(value) {
+	const code = typeof value === "string" ? value.codePointAt(0) : 0;
+	return code === 67 || code === 99 ? 99 : code === 76 || code === 108 ? 108 : code === 82 || code === 114 ? 114 : 0;
+}
+
+//#endregion
+export { markdownTable as t };