prismatica 0.2.0

package/node_modules/fast-wrap-ansi/lib/main.js

@@ -0,0 +1,218 @@
+import stringWidth from 'fast-string-width';
+const ESC = '\x1B';
+const CSI = '\x9B';
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, 'y');
+const getClosingCode = (openingCode) => {
+    if (openingCode >= 30 && openingCode <= 37)
+        return 39;
+    if (openingCode >= 90 && openingCode <= 97)
+        return 39;
+    if (openingCode >= 40 && openingCode <= 47)
+        return 49;
+    if (openingCode >= 100 && openingCode <= 107)
+        return 49;
+    if (openingCode === 1 || openingCode === 2)
+        return 22;
+    if (openingCode === 3)
+        return 23;
+    if (openingCode === 4)
+        return 24;
+    if (openingCode === 7)
+        return 27;
+    if (openingCode === 8)
+        return 28;
+    if (openingCode === 9)
+        return 29;
+    if (openingCode === 0)
+        return 0;
+    return undefined;
+};
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+    const characters = word[Symbol.iterator]();
+    let isInsideEscape = false;
+    let isInsideLinkEscape = false;
+    let lastRow = rows.at(-1);
+    let visible = lastRow === undefined ? 0 : stringWidth(lastRow);
+    let currentCharacter = characters.next();
+    let nextCharacter = characters.next();
+    let rawCharacterIndex = 0;
+    while (!currentCharacter.done) {
+        const character = currentCharacter.value;
+        const characterLength = stringWidth(character);
+        if (visible + characterLength <= columns) {
+            rows[rows.length - 1] += character;
+        }
+        else {
+            rows.push(character);
+            visible = 0;
+        }
+        if (character === ESC || character === CSI) {
+            isInsideEscape = true;
+            isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+        }
+        if (isInsideEscape) {
+            if (isInsideLinkEscape) {
+                if (character === ANSI_ESCAPE_BELL) {
+                    isInsideEscape = false;
+                    isInsideLinkEscape = false;
+                }
+            }
+            else if (character === ANSI_SGR_TERMINATOR) {
+                isInsideEscape = false;
+            }
+        }
+        else {
+            visible += characterLength;
+            if (visible === columns && !nextCharacter.done) {
+                rows.push('');
+                visible = 0;
+            }
+        }
+        currentCharacter = nextCharacter;
+        nextCharacter = characters.next();
+        rawCharacterIndex += character.length;
+    }
+    lastRow = rows.at(-1);
+    if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+        rows[rows.length - 2] += rows.pop();
+    }
+};
+const stringVisibleTrimSpacesRight = (string) => {
+    const words = string.split(' ');
+    let last = words.length;
+    while (last) {
+        if (stringWidth(words[last - 1])) {
+            break;
+        }
+        last--;
+    }
+    if (last === words.length) {
+        return string;
+    }
+    return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
+const exec = (string, columns, options = {}) => {
+    if (options.trim !== false && string.trim() === '') {
+        return '';
+    }
+    let returnValue = '';
+    let escapeCode;
+    let escapeUrl;
+    const words = string.split(' ');
+    let rows = [''];
+    let rowLength = 0;
+    for (let index = 0; index < words.length; index++) {
+        const word = words[index];
+        if (options.trim !== false) {
+            const row = rows.at(-1) ?? '';
+            const trimmed = row.trimStart();
+            if (row.length !== trimmed.length) {
+                rows[rows.length - 1] = trimmed;
+                rowLength = stringWidth(trimmed);
+            }
+        }
+        if (index !== 0) {
+            if (rowLength >= columns &&
+                (options.wordWrap === false || options.trim === false)) {
+                rows.push('');
+                rowLength = 0;
+            }
+            if (rowLength || options.trim === false) {
+                rows[rows.length - 1] += ' ';
+                rowLength++;
+            }
+        }
+        const wordLength = stringWidth(word);
+        if (options.hard && wordLength > columns) {
+            const remainingColumns = columns - rowLength;
+            const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+            const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+            if (breaksStartingNextLine < breaksStartingThisLine) {
+                rows.push('');
+            }
+            wrapWord(rows, word, columns);
+            rowLength = stringWidth(rows.at(-1) ?? '');
+            continue;
+        }
+        if (rowLength + wordLength > columns && rowLength && wordLength) {
+            if (options.wordWrap === false && rowLength < columns) {
+                wrapWord(rows, word, columns);
+                rowLength = stringWidth(rows.at(-1) ?? '');
+                continue;
+            }
+            rows.push('');
+            rowLength = 0;
+        }
+        if (rowLength + wordLength > columns && options.wordWrap === false) {
+            wrapWord(rows, word, columns);
+            rowLength = stringWidth(rows.at(-1) ?? '');
+            continue;
+        }
+        rows[rows.length - 1] += word;
+        rowLength += wordLength;
+    }
+    if (options.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+    }
+    const preString = rows.join('\n');
+    let inSurrogate = false;
+    for (let i = 0; i < preString.length; i++) {
+        const character = preString[i];
+        returnValue += character;
+        if (!inSurrogate) {
+            inSurrogate = character >= '\ud800' && character <= '\udbff';
+            if (inSurrogate) {
+                continue;
+            }
+        }
+        else {
+            inSurrogate = false;
+        }
+        if (character === ESC || character === CSI) {
+            GROUP_REGEX.lastIndex = i + 1;
+            const groupsResult = GROUP_REGEX.exec(preString);
+            const groups = groupsResult?.groups;
+            if (groups?.code !== undefined) {
+                const code = Number.parseFloat(groups.code);
+                escapeCode = code === END_CODE ? undefined : code;
+            }
+            else if (groups?.uri !== undefined) {
+                escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+            }
+        }
+        if (preString[i + 1] === '\n') {
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink('');
+            }
+            const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+            if (escapeCode && closingCode) {
+                returnValue += wrapAnsiCode(closingCode);
+            }
+        }
+        else if (character === '\n') {
+            if (escapeCode && getClosingCode(escapeCode)) {
+                returnValue += wrapAnsiCode(escapeCode);
+            }
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink(escapeUrl);
+            }
+        }
+    }
+    return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+export function wrapAnsi(string, columns, options) {
+    return String(string)
+        .normalize()
+        .split(CRLF_OR_LF)
+        .map((line) => exec(line, columns, options))
+        .join('\n');
+}

package/node_modules/fast-wrap-ansi/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "fast-wrap-ansi",
+  "version": "0.2.2",
+  "files": [
+    "lib"
+  ],
+  "description": "A tiny and fast text wrap library which takes ANSI escapes into account.",
+  "keywords": [
+    "wrap",
+    "ansi",
+    "term",
+    "colors"
+  ],
+  "homepage": "https://github.com/43081j/fast-wrap-ansi#readme",
+  "bugs": {
+    "url": "https://github.com/43081j/fast-wrap-ansi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/43081j/fast-wrap-ansi.git"
+  },
+  "license": "MIT",
+  "author": "James Garbutt (https://github.com/43081j)",
+  "type": "module",
+  "main": "lib/main.js",
+  "scripts": {
+    "format": "prettier --write src test",
+    "lint": "npm run lint:js && npm run lint:format && npm run lint:types",
+    "lint:js": "eslint src test",
+    "lint:format": "prettier --check src test",
+    "lint:types": "npx tsc --noEmit -p tsconfig.test.json",
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.8.0",
+    "eslint": "^10.4.0",
+    "fast-wrap-ansi-prod": "npm:fast-wrap-ansi@*",
+    "picocolors": "^1.1.1",
+    "prettier": "^3.8.3",
+    "tinybench": "^6.0.2",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^4.1.6",
+    "wrap-ansi": "^10.0.0"
+  },
+  "dependencies": {
+    "fast-string-width": "^3.0.2"
+  }
+}

package/node_modules/figures/index.d.ts

@@ -0,0 +1,279 @@
+declare const figureSet: {
+	readonly tick: string;
+	readonly info: string;
+	readonly warning: string;
+	readonly cross: string;
+	readonly square: string;
+	readonly squareSmall: string;
+	readonly squareSmallFilled: string;
+	readonly squareDarkShade: string;
+	readonly squareMediumShade: string;
+	readonly squareLightShade: string;
+	readonly squareTop: string;
+	readonly squareBottom: string;
+	readonly squareLeft: string;
+	readonly squareRight: string;
+	readonly squareCenter: string;
+	readonly circle: string;
+	readonly circleFilled: string;
+	readonly circleDotted: string;
+	readonly circleDouble: string;
+	readonly circleCircle: string;
+	readonly circleCross: string;
+	readonly circlePipe: string;
+	readonly circleQuestionMark: string;
+	readonly radioOn: string;
+	readonly radioOff: string;
+	readonly checkboxOn: string;
+	readonly checkboxOff: string;
+	readonly checkboxCircleOn: string;
+	readonly checkboxCircleOff: string;
+	readonly questionMarkPrefix: string;
+	readonly bullet: string;
+	readonly dot: string;
+	readonly ellipsis: string;
+	readonly pointer: string;
+	readonly pointerSmall: string;
+	readonly triangleUp: string;
+	readonly triangleUpSmall: string;
+	readonly triangleUpOutline: string;
+	readonly triangleDown: string;
+	readonly triangleDownSmall: string;
+	readonly triangleLeft: string;
+	readonly triangleLeftSmall: string;
+	readonly triangleRight: string;
+	readonly triangleRightSmall: string;
+	readonly lozenge: string;
+	readonly lozengeOutline: string;
+	readonly home: string;
+	readonly hamburger: string;
+	readonly smiley: string;
+	readonly mustache: string;
+	readonly heart: string;
+	readonly star: string;
+	readonly play: string;
+	readonly musicNote: string;
+	readonly musicNoteBeamed: string;
+	readonly nodejs: string;
+	readonly arrowUp: string;
+	readonly arrowDown: string;
+	readonly arrowLeft: string;
+	readonly arrowRight: string;
+	readonly arrowLeftRight: string;
+	readonly arrowUpDown: string;
+	readonly almostEqual: string;
+	readonly notEqual: string;
+	readonly lessOrEqual: string;
+	readonly greaterOrEqual: string;
+	readonly identical: string;
+	readonly infinity: string;
+	readonly subscriptZero: string;
+	readonly subscriptOne: string;
+	readonly subscriptTwo: string;
+	readonly subscriptThree: string;
+	readonly subscriptFour: string;
+	readonly subscriptFive: string;
+	readonly subscriptSix: string;
+	readonly subscriptSeven: string;
+	readonly subscriptEight: string;
+	readonly subscriptNine: string;
+	readonly oneHalf: string;
+	readonly oneThird: string;
+	readonly oneQuarter: string;
+	readonly oneFifth: string;
+	readonly oneSixth: string;
+	readonly oneSeventh: string;
+	readonly oneEighth: string;
+	readonly oneNinth: string;
+	readonly oneTenth: string;
+	readonly twoThirds: string;
+	readonly twoFifths: string;
+	readonly threeQuarters: string;
+	readonly threeFifths: string;
+	readonly threeEighths: string;
+	readonly fourFifths: string;
+	readonly fiveSixths: string;
+	readonly fiveEighths: string;
+	readonly sevenEighth: string;
+	readonly line: string;
+	readonly lineBold: string;
+	readonly lineDouble: string;
+	readonly lineDashed0: string;
+	readonly lineDashed1: string;
+	readonly lineDashed2: string;
+	readonly lineDashed3: string;
+	readonly lineDashed4: string;
+	readonly lineDashed5: string;
+	readonly lineDashed6: string;
+	readonly lineDashed7: string;
+	readonly lineDashed8: string;
+	readonly lineDashed9: string;
+	readonly lineDashed10: string;
+	readonly lineDashed11: string;
+	readonly lineDashed12: string;
+	readonly lineDashed13: string;
+	readonly lineDashed14: string;
+	readonly lineDashed15: string;
+	readonly lineVertical: string;
+	readonly lineVerticalBold: string;
+	readonly lineVerticalDouble: string;
+	readonly lineVerticalDashed0: string;
+	readonly lineVerticalDashed1: string;
+	readonly lineVerticalDashed2: string;
+	readonly lineVerticalDashed3: string;
+	readonly lineVerticalDashed4: string;
+	readonly lineVerticalDashed5: string;
+	readonly lineVerticalDashed6: string;
+	readonly lineVerticalDashed7: string;
+	readonly lineVerticalDashed8: string;
+	readonly lineVerticalDashed9: string;
+	readonly lineVerticalDashed10: string;
+	readonly lineVerticalDashed11: string;
+	readonly lineDownLeft: string;
+	readonly lineDownLeftArc: string;
+	readonly lineDownBoldLeftBold: string;
+	readonly lineDownBoldLeft: string;
+	readonly lineDownLeftBold: string;
+	readonly lineDownDoubleLeftDouble: string;
+	readonly lineDownDoubleLeft: string;
+	readonly lineDownLeftDouble: string;
+	readonly lineDownRight: string;
+	readonly lineDownRightArc: string;
+	readonly lineDownBoldRightBold: string;
+	readonly lineDownBoldRight: string;
+	readonly lineDownRightBold: string;
+	readonly lineDownDoubleRightDouble: string;
+	readonly lineDownDoubleRight: string;
+	readonly lineDownRightDouble: string;
+	readonly lineUpLeft: string;
+	readonly lineUpLeftArc: string;
+	readonly lineUpBoldLeftBold: string;
+	readonly lineUpBoldLeft: string;
+	readonly lineUpLeftBold: string;
+	readonly lineUpDoubleLeftDouble: string;
+	readonly lineUpDoubleLeft: string;
+	readonly lineUpLeftDouble: string;
+	readonly lineUpRight: string;
+	readonly lineUpRightArc: string;
+	readonly lineUpBoldRightBold: string;
+	readonly lineUpBoldRight: string;
+	readonly lineUpRightBold: string;
+	readonly lineUpDoubleRightDouble: string;
+	readonly lineUpDoubleRight: string;
+	readonly lineUpRightDouble: string;
+	readonly lineUpDownLeft: string;
+	readonly lineUpBoldDownBoldLeftBold: string;
+	readonly lineUpBoldDownBoldLeft: string;
+	readonly lineUpDownLeftBold: string;
+	readonly lineUpBoldDownLeftBold: string;
+	readonly lineUpDownBoldLeftBold: string;
+	readonly lineUpDownBoldLeft: string;
+	readonly lineUpBoldDownLeft: string;
+	readonly lineUpDoubleDownDoubleLeftDouble: string;
+	readonly lineUpDoubleDownDoubleLeft: string;
+	readonly lineUpDownLeftDouble: string;
+	readonly lineUpDownRight: string;
+	readonly lineUpBoldDownBoldRightBold: string;
+	readonly lineUpBoldDownBoldRight: string;
+	readonly lineUpDownRightBold: string;
+	readonly lineUpBoldDownRightBold: string;
+	readonly lineUpDownBoldRightBold: string;
+	readonly lineUpDownBoldRight: string;
+	readonly lineUpBoldDownRight: string;
+	readonly lineUpDoubleDownDoubleRightDouble: string;
+	readonly lineUpDoubleDownDoubleRight: string;
+	readonly lineUpDownRightDouble: string;
+	readonly lineDownLeftRight: string;
+	readonly lineDownBoldLeftBoldRightBold: string;
+	readonly lineDownLeftBoldRightBold: string;
+	readonly lineDownBoldLeftRight: string;
+	readonly lineDownBoldLeftBoldRight: string;
+	readonly lineDownBoldLeftRightBold: string;
+	readonly lineDownLeftRightBold: string;
+	readonly lineDownLeftBoldRight: string;
+	readonly lineDownDoubleLeftDoubleRightDouble: string;
+	readonly lineDownDoubleLeftRight: string;
+	readonly lineDownLeftDoubleRightDouble: string;
+	readonly lineUpLeftRight: string;
+	readonly lineUpBoldLeftBoldRightBold: string;
+	readonly lineUpLeftBoldRightBold: string;
+	readonly lineUpBoldLeftRight: string;
+	readonly lineUpBoldLeftBoldRight: string;
+	readonly lineUpBoldLeftRightBold: string;
+	readonly lineUpLeftRightBold: string;
+	readonly lineUpLeftBoldRight: string;
+	readonly lineUpDoubleLeftDoubleRightDouble: string;
+	readonly lineUpDoubleLeftRight: string;
+	readonly lineUpLeftDoubleRightDouble: string;
+	readonly lineUpDownLeftRight: string;
+	readonly lineUpBoldDownBoldLeftBoldRightBold: string;
+	readonly lineUpDownBoldLeftBoldRightBold: string;
+	readonly lineUpBoldDownLeftBoldRightBold: string;
+	readonly lineUpBoldDownBoldLeftRightBold: string;
+	readonly lineUpBoldDownBoldLeftBoldRight: string;
+	readonly lineUpBoldDownLeftRight: string;
+	readonly lineUpDownBoldLeftRight: string;
+	readonly lineUpDownLeftBoldRight: string;
+	readonly lineUpDownLeftRightBold: string;
+	readonly lineUpBoldDownBoldLeftRight: string;
+	readonly lineUpDownLeftBoldRightBold: string;
+	readonly lineUpBoldDownLeftBoldRight: string;
+	readonly lineUpBoldDownLeftRightBold: string;
+	readonly lineUpDownBoldLeftBoldRight: string;
+	readonly lineUpDownBoldLeftRightBold: string;
+	readonly lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+	readonly lineUpDoubleDownDoubleLeftRight: string;
+	readonly lineUpDownLeftDoubleRightDouble: string;
+	readonly lineCross: string;
+	readonly lineBackslash: string;
+	readonly lineSlash: string;
+};
+
+type FigureSet = typeof figureSet;
+
+/**
+Symbols to use when the terminal supports Unicode symbols.
+*/
+export const mainSymbols: FigureSet;
+
+/**
+Symbols to use when the terminal does not support Unicode symbols.
+*/
+export const fallbackSymbols: FigureSet;
+
+/**
+Symbols to use on any terminal.
+*/
+export default figureSet;
+
+export type Options = {
+	/**
+	Whether to replace symbols with fallbacks.
+
+	This can be set to `true` to always use fallback symbols, whether the terminal has poor Unicode support or not.
+
+	@default `true` if the terminal has poor Unicode support
+	*/
+	readonly useFallback?: boolean;
+};
+
+/**
+Returns the input with replaced fallback symbols if the terminal has poor Unicode support.
+
+@param string - String where the Unicode symbols will be replaced with fallback symbols depending on the terminal.
+@returns The input with replaced fallback Unicode symbols.
+
+@example
+```
+import figures, {replaceSymbols} from 'figures';
+
+console.log(replaceSymbols('✔ check'));
+// On terminals with Unicode symbols:  ✔ check
+// On other terminals:                 √ check
+
+console.log(replaceSymbols('✔ check', {useFallback: true}));
+// On terminals with Unicode symbols:  √ check
+// On other terminals:                 √ check
+```
+*/
+export function replaceSymbols(string: string, options?: Options): string;