decocms 2.297.4 → 2.297.5

package/dist/server/node_modules/scheduler/unstable_mock.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/scheduler-unstable_mock.production.js');
+} else {
+  module.exports = require('./cjs/scheduler-unstable_mock.development.js');
+}

package/dist/server/node_modules/scheduler/unstable_post_task.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/scheduler-unstable_post_task.production.js');
+} else {
+  module.exports = require('./cjs/scheduler-unstable_post_task.development.js');
+}

package/dist/server/node_modules/slice-ansi/index.d.ts

@@ -0,0 +1,19 @@
+/**
+Slice a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
+
+@param string - A string with ANSI escape codes. Like one styled by [`chalk`](https://github.com/chalk/chalk).
+@param startSlice - Zero-based visible-column index at which to start the slice. Grapheme clusters are kept intact.
+@param endSlice - Zero-based visible-column index at which to end the slice.
+
+@example
+```
+import chalk from 'chalk';
+import sliceAnsi from 'slice-ansi';
+
+const string = 'The quick brown ' + chalk.red('fox jumped over ') +
+	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
+
+console.log(sliceAnsi(string, 20, 30));
+```
+*/
+export default function sliceAnsi(string: string, startSlice: number, endSlice?: number): string;

package/dist/server/node_modules/slice-ansi/index.js

@@ -0,0 +1,260 @@
+import tokenizeAnsi from './tokenize-ansi.js';
+
+function applySgrFragments(activeStyles, fragments) {
+	for (const fragment of fragments) {
+		switch (fragment.type) {
+			case 'reset': {
+				activeStyles.clear();
+				break;
+			}
+
+			case 'end': {
+				activeStyles.delete(fragment.endCode);
+				break;
+			}
+
+			case 'start': {
+				activeStyles.delete(fragment.endCode);
+				activeStyles.set(fragment.endCode, fragment.code);
+				break;
+			}
+
+			default: {
+				break;
+			}
+		}
+	}
+
+	return activeStyles;
+}
+
+function undoAnsiCodes(activeStyles) {
+	return [...activeStyles.keys()].reverse().join('');
+}
+
+function closeHyperlink(hyperlinkToken) {
+	return `${hyperlinkToken.closePrefix}${hyperlinkToken.terminator}`;
+}
+
+function shouldIncludeSgrAfterEnd(token, activeStyles) {
+	let hasStartFragment = false;
+	let hasClosingEffect = false;
+
+	for (const fragment of token.fragments) {
+		if (fragment.type === 'start') {
+			hasStartFragment = true;
+			continue;
+		}
+
+		if (fragment.type === 'reset' && activeStyles.size > 0) {
+			hasClosingEffect = true;
+			continue;
+		}
+
+		if (fragment.type === 'end' && activeStyles.has(fragment.endCode)) {
+			hasClosingEffect = true;
+		}
+	}
+
+	return hasClosingEffect && !hasStartFragment;
+}
+
+function applySgrToken({token, isPastEnd, activeStyles, returnValue, include, activeHyperlink, position}) {
+	if (isPastEnd && !shouldIncludeSgrAfterEnd(token, activeStyles)) {
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
+	}
+
+	activeStyles = applySgrFragments(activeStyles, token.fragments);
+	if (include) {
+		returnValue += token.code;
+	}
+
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
+}
+
+function applyHyperlinkToken({token, isPastEnd, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (
+		isPastEnd
+		&& (
+			token.action !== 'close'
+			|| !activeHyperlink
+		)
+	) {
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
+	}
+
+	if (token.action === 'open') {
+		activeHyperlink = token;
+	} else if (token.action === 'close') {
+		activeHyperlink = undefined;
+	}
+
+	if (include) {
+		returnValue += token.code;
+	}
+
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
+}
+
+function applyControlToken({token, isPastEnd, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (!isPastEnd && include) {
+		returnValue += token.code;
+	}
+
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
+}
+
+function applyCharacterToken({token, start, activeStyles, activeHyperlink, position, returnValue, include}) {
+	if (
+		!include
+		&& position >= start
+		&& !token.isGraphemeContinuation
+	) {
+		include = true;
+		returnValue = [...activeStyles.values()].join('');
+		if (activeHyperlink) {
+			returnValue += activeHyperlink.code;
+		}
+	}
+
+	if (include) {
+		returnValue += token.value;
+	}
+
+	position += token.visibleWidth;
+	return {
+		activeStyles,
+		activeHyperlink,
+		position,
+		returnValue,
+		include,
+	};
+}
+
+const tokenHandlers = {
+	sgr: applySgrToken,
+	hyperlink: applyHyperlinkToken,
+	control: applyControlToken,
+	character: applyCharacterToken,
+};
+
+function applyToken(parameters) {
+	const tokenHandler = tokenHandlers[parameters.token.type];
+	if (!tokenHandler) {
+		const {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		} = parameters;
+
+		return {
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		};
+	}
+
+	return tokenHandler(parameters);
+}
+
+function createHasContinuationAheadMap(tokens) {
+	const hasContinuationAhead = Array.from({length: tokens.length}, () => false);
+	let nextCharacterIsContinuation = false;
+
+	for (let tokenIndex = tokens.length - 1; tokenIndex >= 0; tokenIndex--) {
+		const token = tokens[tokenIndex];
+		hasContinuationAhead[tokenIndex] = nextCharacterIsContinuation;
+		if (token.type === 'character') {
+			nextCharacterIsContinuation = Boolean(token.isGraphemeContinuation);
+		}
+	}
+
+	return hasContinuationAhead;
+}
+
+export default function sliceAnsi(string, start, end) {
+	const tokens = tokenizeAnsi(string, {endCharacter: end});
+	const hasContinuationAhead = createHasContinuationAheadMap(tokens);
+	let activeStyles = new Map();
+	let activeHyperlink;
+	let position = 0;
+	let returnValue = '';
+	let include = false;
+
+	for (const [tokenIndex, token] of tokens.entries()) {
+		let isPastEnd = end !== undefined && position >= end;
+		if (
+			isPastEnd
+			&& token.type !== 'character'
+			&& hasContinuationAhead[tokenIndex]
+		) {
+			isPastEnd = false;
+		}
+
+		if (
+			isPastEnd
+			&& token.type === 'character'
+			&& !token.isGraphemeContinuation
+		) {
+			break;
+		}
+
+		({activeStyles, activeHyperlink, position, returnValue, include} = applyToken({
+			token,
+			isPastEnd,
+			start,
+			activeStyles,
+			activeHyperlink,
+			position,
+			returnValue,
+			include,
+		}));
+	}
+
+	if (!include) {
+		return '';
+	}
+
+	if (activeHyperlink) {
+		returnValue += closeHyperlink(activeHyperlink);
+	}
+
+	// Disable active codes at the end
+	returnValue += undoAnsiCodes(activeStyles);
+
+	return returnValue;
+}

package/dist/server/node_modules/{is-unicode-supported → slice-ansi}/license

@@ -1,5 +1,6 @@
 MIT License
 
+Copyright (c) DC <threedeecee@gmail.com>
 Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

package/dist/server/node_modules/slice-ansi/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "slice-ansi",
+	"version": "8.0.0",
+	"description": "Slice a string with ANSI escape codes",
+	"license": "MIT",
+	"repository": "chalk/slice-ansi",
+	"funding": "https://github.com/chalk/slice-ansi?sponsor=1",
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=20"
+	},
+	"scripts": {
+		"test": "xo && ava && tsc --lib esnext index.d.ts"
+	},
+	"files": [
+		"index.js",
+		"tokenize-ansi.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"slice",
+		"string",
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"ansi-styles": "^6.2.3",
+		"is-fullwidth-code-point": "^5.1.0"
+	},
+	"devDependencies": {
+		"ava": "^6.4.1",
+		"chalk": "^5.6.2",
+		"random-item": "^4.0.1",
+		"strip-ansi": "^7.1.2",
+		"xo": "^1.2.3"
+	}
+}

package/dist/server/node_modules/slice-ansi/readme.md

@@ -0,0 +1,54 @@
+# slice-ansi [![XO: Linted](https://img.shields.io/badge/xo-linted-blue.svg)](https://github.com/xojs/xo)
+
+> Slice a string with [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
+
+## Install
+
+```sh
+npm install slice-ansi
+```
+
+## Usage
+
+```js
+import chalk from 'chalk';
+import sliceAnsi from 'slice-ansi';
+
+const string = 'The quick brown ' + chalk.red('fox jumped over ') +
+	'the lazy ' + chalk.green('dog and then ran away with the unicorn.');
+
+console.log(sliceAnsi(string, 20, 30));
+```
+
+## API
+
+### sliceAnsi(string, startSlice, endSlice?)
+
+#### string
+
+Type: `string`
+
+String with ANSI escape codes. Like one styled by [`chalk`](https://github.com/chalk/chalk).
+
+#### startSlice
+
+Type: `number`
+
+Zero-based visible-column index at which to start the slice. Grapheme clusters (for example, emoji sequences and combining marks) are kept intact.
+
+#### endSlice
+
+Type: `number`
+
+Zero-based visible-column index at which to end the slice.
+
+## Related
+
+- [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
+- [cli-truncate](https://github.com/sindresorhus/cli-truncate) - Truncate a string to a specific width in the terminal
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)