@alivault/pico 0.14.0 → 0.16.1

package/.output/server/_libs/markdown-table.mjs

@@ -1,289 +0,0 @@
-//#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 };

package/.output/server/_libs/mdast-util-find-and-replace.mjs

@@ -1,198 +0,0 @@
-import { i as convert, r as visitParents } from "./hast-util-raw+[...].mjs";
-import { t as escapeStringRegexp } from "./escape-string-regexp.mjs";
-//#region node_modules/.pnpm/mdast-util-find-and-replace@3.0.2/node_modules/mdast-util-find-and-replace/lib/index.js
-/**
-* @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'
-* @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'
-*/
-/**
-* @typedef RegExpMatchObject
-*   Info on the match.
-* @property {number} index
-*   The index of the search at which the result was found.
-* @property {string} input
-*   A copy of the search string in the text node.
-* @property {[...Array<Parents>, Text]} stack
-*   All ancestors of the text node, where the last node is the text itself.
-*
-* @typedef {RegExp | string} Find
-*   Pattern to find.
-*
-*   Strings are escaped and then turned into global expressions.
-*
-* @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
-*   Several find and replaces, in array form.
-*
-* @typedef {[Find, Replace?]} FindAndReplaceTuple
-*   Find and replace in tuple form.
-*
-* @typedef {ReplaceFunction | string | null | undefined} Replace
-*   Thing to replace with.
-*
-* @callback ReplaceFunction
-*   Callback called when a search matches.
-* @param {...any} parameters
-*   The parameters are the result of corresponding search expression:
-*
-*   * `value` (`string`) — whole match
-*   * `...capture` (`Array<string>`) — matches from regex capture groups
-*   * `match` (`RegExpMatchObject`) — info on the match
-* @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}
-*   Thing to replace with.
-*
-*   * when `null`, `undefined`, `''`, remove the match
-*   * …or when `false`, do not replace at all
-*   * …or when `string`, replace with a text node of that value
-*   * …or when `Node` or `Array<Node>`, replace with those nodes
-*
-* @typedef {[RegExp, ReplaceFunction]} Pair
-*   Normalized find and replace.
-*
-* @typedef {Array<Pair>} Pairs
-*   All find and replaced.
-*
-* @typedef Options
-*   Configuration.
-* @property {Test | null | undefined} [ignore]
-*   Test for which nodes to ignore (optional).
-*/
-/**
-* Find patterns in a tree and replace them.
-*
-* The algorithm searches the tree in *preorder* for complete values in `Text`
-* nodes.
-* Partial matches are not supported.
-*
-* @param {Nodes} tree
-*   Tree to change.
-* @param {FindAndReplaceList | FindAndReplaceTuple} list
-*   Patterns to find.
-* @param {Options | null | undefined} [options]
-*   Configuration (when `find` is not `Find`).
-* @returns {undefined}
-*   Nothing.
-*/
-function findAndReplace(tree, list, options) {
-	const ignored = convert((options || {}).ignore || []);
-	const pairs = toPairs(list);
-	let pairIndex = -1;
-	while (++pairIndex < pairs.length) visitParents(tree, "text", visitor);
-	/** @type {BuildVisitor<Root, 'text'>} */
-	function visitor(node, parents) {
-		let index = -1;
-		/** @type {Parents | undefined} */
-		let grandparent;
-		while (++index < parents.length) {
-			const parent = parents[index];
-			/** @type {Array<Nodes> | undefined} */
-			const siblings = grandparent ? grandparent.children : void 0;
-			if (ignored(parent, siblings ? siblings.indexOf(parent) : void 0, grandparent)) return;
-			grandparent = parent;
-		}
-		if (grandparent) return handler(node, parents);
-	}
-	/**
-	* Handle a text node which is not in an ignored parent.
-	*
-	* @param {Text} node
-	*   Text node.
-	* @param {Array<Parents>} parents
-	*   Parents.
-	* @returns {VisitorResult}
-	*   Result.
-	*/
-	function handler(node, parents) {
-		const parent = parents[parents.length - 1];
-		const find = pairs[pairIndex][0];
-		const replace = pairs[pairIndex][1];
-		let start = 0;
-		const index = parent.children.indexOf(node);
-		let change = false;
-		/** @type {Array<PhrasingContent>} */
-		let nodes = [];
-		find.lastIndex = 0;
-		let match = find.exec(node.value);
-		while (match) {
-			const position = match.index;
-			/** @type {RegExpMatchObject} */
-			const matchObject = {
-				index: match.index,
-				input: match.input,
-				stack: [...parents, node]
-			};
-			let value = replace(...match, matchObject);
-			if (typeof value === "string") value = value.length > 0 ? {
-				type: "text",
-				value
-			} : void 0;
-			if (value === false) find.lastIndex = position + 1;
-			else {
-				if (start !== position) nodes.push({
-					type: "text",
-					value: node.value.slice(start, position)
-				});
-				if (Array.isArray(value)) nodes.push(...value);
-				else if (value) nodes.push(value);
-				start = position + match[0].length;
-				change = true;
-			}
-			if (!find.global) break;
-			match = find.exec(node.value);
-		}
-		if (change) {
-			if (start < node.value.length) nodes.push({
-				type: "text",
-				value: node.value.slice(start)
-			});
-			parent.children.splice(index, 1, ...nodes);
-		} else nodes = [node];
-		return index + nodes.length;
-	}
-}
-/**
-* Turn a tuple or a list of tuples into pairs.
-*
-* @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList
-*   Schema.
-* @returns {Pairs}
-*   Clean pairs.
-*/
-function toPairs(tupleOrList) {
-	/** @type {Pairs} */
-	const result = [];
-	if (!Array.isArray(tupleOrList)) throw new TypeError("Expected find and replace tuple or list of tuples");
-	/** @type {FindAndReplaceList} */
-	const list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
-	let index = -1;
-	while (++index < list.length) {
-		const tuple = list[index];
-		result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
-	}
-	return result;
-}
-/**
-* Turn a find into an expression.
-*
-* @param {Find} find
-*   Find.
-* @returns {RegExp}
-*   Expression.
-*/
-function toExpression(find) {
-	return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
-}
-/**
-* Turn a replace into a function.
-*
-* @param {Replace} replace
-*   Replace.
-* @returns {ReplaceFunction}
-*   Function.
-*/
-function toFunction(replace) {
-	return typeof replace === "function" ? replace : function() {
-		return replace;
-	};
-}
-//#endregion
-export { findAndReplace as t };