@highstate/designer 0.4.5 → 0.5.0

package/.output/server/node_modules/mlly/package.json

@@ -1,50 +0,0 @@
-{
-  "name": "mlly",
-  "version": "1.7.4",
-  "description": "Missing ECMAScript module utils for Node.js",
-  "repository": "unjs/mlly",
-  "license": "MIT",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.cjs"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "unbuild",
-    "dev": "vitest",
-    "lint": "eslint src test && prettier -c src test",
-    "lint:fix": "eslint src test --fix && prettier -w src test",
-    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
-    "test": "pnpm lint && pnpm test:types && vitest run",
-    "test:types": "tsc --noEmit"
-  },
-  "dependencies": {
-    "acorn": "^8.14.0",
-    "pathe": "^2.0.1",
-    "pkg-types": "^1.3.0",
-    "ufo": "^1.5.4"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.5",
-    "@vitest/coverage-v8": "^2.1.8",
-    "changelogen": "^0.5.7",
-    "eslint": "^9.17.0",
-    "eslint-config-unjs": "^0.4.2",
-    "import-meta-resolve": "^4.1.0",
-    "jiti": "^2.4.2",
-    "prettier": "^3.4.2",
-    "std-env": "^3.8.0",
-    "typescript": "^5.7.2",
-    "unbuild": "^3.2.0",
-    "vitest": "^2.1.8"
-  },
-  "packageManager": "pnpm@9.15.3"
-}

package/.output/server/node_modules/module-error/index.js

@@ -1,22 +0,0 @@
-'use strict'
-
-module.exports = class ModuleError extends Error {
-  /**
-   * @param {string} message Error message
-   * @param {{ code?: string, cause?: Error, expected?: boolean, transient?: boolean }} [options]
-   */
-  constructor (message, options) {
-    super(message || '')
-
-    if (typeof options === 'object' && options !== null) {
-      if (options.code) this.code = String(options.code)
-      if (options.expected) this.expected = true
-      if (options.transient) this.transient = true
-      if (options.cause) this.cause = options.cause
-    }
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor)
-    }
-  }
-}

package/.output/server/node_modules/module-error/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "module-error",
-  "version": "1.0.2",
-  "description": "Create errors with code and cause properties",
-  "license": "MIT",
-  "author": "Vincent Weevers",
-  "scripts": {
-    "test": "standard && tsc && hallmark && node test",
-    "build": "tsc -d --emitDeclarationOnly --noEmit false"
-  },
-  "types": "./index.d.ts",
-  "files": [
-    "index.js",
-    "index.d.ts",
-    "CHANGELOG.md"
-  ],
-  "devDependencies": {
-    "@types/node": "^17.0.6",
-    "@voxpelli/tsconfig": "^3.0.0",
-    "hallmark": "^4.0.0",
-    "standard": "^16.0.4",
-    "tape": "^5.3.1",
-    "typescript": "^4.4.4"
-  },
-  "keywords": [
-    "cause",
-    "code",
-    "error"
-  ],
-  "repository": "vweevers/module-error",
-  "bugs": "https://github.com/vweevers/module-error/issues",
-  "homepage": "https://github.com/vweevers/module-error",
-  "engines": {
-    "node": ">=10"
-  }
-}

package/.output/server/node_modules/nano-spawn/package.json

@@ -1,66 +0,0 @@
-{
-  "name": "nano-spawn",
-  "version": "0.2.0",
-  "description": "Tiny process execution for humans — a better child_process",
-  "license": "MIT",
-  "repository": "sindresorhus/nano-spawn",
-  "funding": "https://github.com/sindresorhus/nano-spawn?sponsor=1",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "https://sindresorhus.com"
-  },
-  "type": "module",
-  "exports": {
-    "types": "./source/index.d.ts",
-    "default": "./source/index.js"
-  },
-  "sideEffects": false,
-  "engines": {
-    "node": ">=18.19"
-  },
-  "scripts": {
-    "test": "xo && c8 ava && npm run type",
-    "type": "tsd -t ./source/index.d.ts -f ./source/index.test-d.ts"
-  },
-  "files": [
-    "source/**/*.js",
-    "source/**/*.d.ts"
-  ],
-  "keywords": [
-    "spawn",
-    "exec",
-    "child",
-    "process",
-    "subprocess",
-    "execute",
-    "fork",
-    "execfile",
-    "file",
-    "shell",
-    "bin",
-    "binary",
-    "binaries",
-    "npm",
-    "path",
-    "local",
-    "zx",
-    "execa"
-  ],
-  "devDependencies": {
-    "@types/node": "^22.5.4",
-    "ava": "^6.1.3",
-    "c8": "^10.1.2",
-    "get-node": "^15.0.1",
-    "path-key": "^4.0.0",
-    "tempy": "^3.1.0",
-    "tsd": "^0.31.2",
-    "typescript": "^5.5.4",
-    "xo": "^0.59.3",
-    "yoctocolors": "^2.1.1"
-  },
-  "ava": {
-    "concurrency": 1,
-    "timeout": "240s"
-  }
-}

package/.output/server/node_modules/nano-spawn/source/context.js

@@ -1,12 +0,0 @@
-import process from 'node:process';
-import {stripVTControlCharacters} from 'node:util';
-
-export const getContext = raw => ({
-	start: process.hrtime.bigint(),
-	command: raw.map(part => getCommandPart(stripVTControlCharacters(part))).join(' '),
-	state: {stdout: '', stderr: '', output: ''},
-});
-
-const getCommandPart = part => /[^\w./-]/.test(part)
-	? `'${part.replaceAll('\'', '\'\\\'\'')}'`
-	: part;

package/.output/server/node_modules/nano-spawn/source/index.js

@@ -1,28 +0,0 @@
-import {getContext} from './context.js';
-import {getOptions} from './options.js';
-import {spawnSubprocess} from './spawn.js';
-import {getResult} from './result.js';
-import {handlePipe} from './pipe.js';
-import {lineIterator, combineAsyncIterators} from './iterable.js';
-
-export {SubprocessError} from './result.js';
-
-export default function spawn(file, second, third, previous) {
-	const [commandArguments = [], options = {}] = Array.isArray(second) ? [second, third] : [[], second];
-	const context = getContext([file, ...commandArguments]);
-	const spawnOptions = getOptions(options);
-	const nodeChildProcess = spawnSubprocess(file, commandArguments, spawnOptions, context);
-	let subprocess = getResult(nodeChildProcess, spawnOptions, context);
-	Object.assign(subprocess, {nodeChildProcess});
-	subprocess = previous ? handlePipe([previous, subprocess]) : subprocess;
-
-	const stdout = lineIterator(subprocess, context, 'stdout');
-	const stderr = lineIterator(subprocess, context, 'stderr');
-	return Object.assign(subprocess, {
-		nodeChildProcess,
-		stdout,
-		stderr,
-		[Symbol.asyncIterator]: () => combineAsyncIterators(stdout, stderr),
-		pipe: (file, second, third) => spawn(file, second, third, subprocess),
-	});
-}

package/.output/server/node_modules/nano-spawn/source/iterable.js

@@ -1,61 +0,0 @@
-export const lineIterator = async function * (subprocess, {state}, streamName) {
-	// Prevent buffering when iterating.
-	// This would defeat one of the main goals of iterating: low memory consumption.
-	if (state.isIterating === false) {
-		throw new Error(`The subprocess must be iterated right away, for example:
-	for await (const line of spawn(...)) { ... }`);
-	}
-
-	state.isIterating = true;
-
-	try {
-		const {[streamName]: stream} = await subprocess.nodeChildProcess;
-		if (!stream) {
-			return;
-		}
-
-		let buffer = '';
-		for await (const chunk of stream.iterator({destroyOnReturn: false})) {
-			const lines = `${buffer}${chunk}`.split(/\r?\n/);
-			buffer = lines.pop(); // Keep last line in buffer as it may not be complete
-			yield * lines;
-		}
-
-		if (buffer) {
-			yield buffer; // Yield any remaining data as the last line
-		}
-	} finally {
-		await subprocess;
-	}
-};
-
-// Merge two async iterators into one
-export const combineAsyncIterators = async function * (...iterators) {
-	try {
-		let promises = [];
-		while (iterators.length > 0) {
-			promises = iterators.map((iterator, index) => promises[index] ?? getNext(iterator));
-			// eslint-disable-next-line no-await-in-loop
-			const [{value, done}, index] = await Promise.race(promises
-				.map((promise, index) => Promise.all([promise, index])));
-
-			const [iterator] = iterators.splice(index, 1);
-			promises.splice(index, 1);
-
-			if (!done) {
-				iterators.push(iterator);
-				yield value;
-			}
-		}
-	} finally {
-		await Promise.all(iterators.map(iterator => iterator.return()));
-	}
-};
-
-const getNext = async iterator => {
-	try {
-		return await iterator.next();
-	} catch (error) {
-		await iterator.throw(error);
-	}
-};

package/.output/server/node_modules/nano-spawn/source/options.js

@@ -1,37 +0,0 @@
-import path from 'node:path';
-import {fileURLToPath} from 'node:url';
-import process from 'node:process';
-
-export const getOptions = ({
-	stdin,
-	stdout,
-	stderr,
-	stdio = [stdin, stdout, stderr],
-	env: envOption,
-	preferLocal,
-	cwd: cwdOption = '.',
-	...options
-}) => {
-	const cwd = cwdOption instanceof URL ? fileURLToPath(cwdOption) : path.resolve(cwdOption);
-	const env = envOption ? {...process.env, ...envOption} : undefined;
-	const input = stdio[0]?.string;
-	return {
-		...options,
-		input,
-		stdio: input === undefined ? stdio : ['pipe', ...stdio.slice(1)],
-		env: preferLocal ? addLocalPath(env ?? process.env, cwd) : env,
-		cwd,
-	};
-};
-
-const addLocalPath = ({Path = '', PATH = Path, ...env}, cwd) => {
-	const pathParts = PATH.split(path.delimiter);
-	const localPaths = getLocalPaths([], path.resolve(cwd))
-		.map(localPath => path.join(localPath, 'node_modules/.bin'))
-		.filter(localPath => !pathParts.includes(localPath));
-	return {...env, PATH: [...localPaths, PATH].filter(Boolean).join(path.delimiter)};
-};
-
-const getLocalPaths = (localPaths, localPath) => localPaths.at(-1) === localPath
-	? localPaths
-	: getLocalPaths([...localPaths, localPath], path.resolve(localPath, '..'));

package/.output/server/node_modules/nano-spawn/source/pipe.js

@@ -1,43 +0,0 @@
-import {pipeline} from 'node:stream/promises';
-
-export const handlePipe = async subprocesses => {
-	// Ensure both subprocesses have exited before resolving, and that we handle errors from both
-	const [[from, to]] = await Promise.all([Promise.allSettled(subprocesses), pipeStreams(subprocesses)]);
-
-	// If both subprocesses fail, throw destination error to use a predictable order and avoid race conditions
-	if (to.reason) {
-		to.reason.pipedFrom = from.reason ?? from.value;
-		throw to.reason;
-	}
-
-	if (from.reason) {
-		throw from.reason;
-	}
-
-	return {...to.value, pipedFrom: from.value};
-};
-
-const pipeStreams = async subprocesses => {
-	try {
-		const [{stdout}, {stdin}] = await Promise.all(subprocesses.map(({nodeChildProcess}) => nodeChildProcess));
-		if (stdin === null) {
-			throw new Error('The "stdin" option must be set on the first "spawn()" call in the pipeline.');
-		}
-
-		if (stdout === null) {
-			throw new Error('The "stdout" option must be set on the last "spawn()" call in the pipeline.');
-		}
-
-		// Do not `await` nor handle stream errors since this is already done by each subprocess
-		// eslint-disable-next-line promise/prefer-await-to-then
-		pipeline(stdout, stdin).catch(() => {});
-	} catch (error) {
-		await Promise.allSettled(subprocesses.map(({nodeChildProcess}) => closeStdin(nodeChildProcess)));
-		throw error;
-	}
-};
-
-const closeStdin = async nodeChildProcess => {
-	const {stdin} = await nodeChildProcess;
-	stdin.end();
-};

package/.output/server/node_modules/nano-spawn/source/result.js

@@ -1,74 +0,0 @@
-import {once, on} from 'node:events';
-import process from 'node:process';
-
-export const getResult = async (nodeChildProcess, {input}, context) => {
-	const instance = await nodeChildProcess;
-	if (input !== undefined) {
-		instance.stdin.end(input);
-	}
-
-	const onClose = once(instance, 'close');
-
-	try {
-		await Promise.race([
-			onClose,
-			...instance.stdio.filter(Boolean).map(stream => onStreamError(stream)),
-		]);
-		checkFailure(context, getErrorOutput(instance));
-		return getOutputs(context);
-	} catch (error) {
-		await Promise.allSettled([onClose]);
-		throw getResultError(error, instance, context);
-	}
-};
-
-const onStreamError = async stream => {
-	for await (const [error] of on(stream, 'error')) {
-		// Ignore errors that are due to closing errors when the subprocesses exit normally, or due to piping
-		if (!['ERR_STREAM_PREMATURE_CLOSE', 'EPIPE'].includes(error?.code)) {
-			throw error;
-		}
-	}
-};
-
-const checkFailure = ({command}, {exitCode, signalName}) => {
-	if (signalName !== undefined) {
-		throw new SubprocessError(`Command was terminated with ${signalName}: ${command}`);
-	}
-
-	if (exitCode !== undefined) {
-		throw new SubprocessError(`Command failed with exit code ${exitCode}: ${command}`);
-	}
-};
-
-export const getResultError = (error, instance, context) => Object.assign(
-	getErrorInstance(error, context),
-	getErrorOutput(instance),
-	getOutputs(context),
-);
-
-const getErrorInstance = (error, {command}) => error instanceof SubprocessError
-	? error
-	: new SubprocessError(`Command failed: ${command}`, {cause: error});
-
-export class SubprocessError extends Error {
-	name = 'SubprocessError';
-}
-
-const getErrorOutput = ({exitCode, signalCode}) => ({
-	// `exitCode` can be a negative number (`errno`) when the `error` event is emitted on the `instance`
-	...(exitCode < 1 ? {} : {exitCode}),
-	...(signalCode === null ? {} : {signalName: signalCode}),
-});
-
-const getOutputs = ({state: {stdout, stderr, output}, command, start}) => ({
-	stdout: getOutput(stdout),
-	stderr: getOutput(stderr),
-	output: getOutput(output),
-	command,
-	durationMs: Number(process.hrtime.bigint() - start) / 1e6,
-});
-
-const getOutput = output => output.at(-1) === '\n'
-	? output.slice(0, output.at(-2) === '\r' ? -2 : -1)
-	: output;

package/.output/server/node_modules/nano-spawn/source/spawn.js

@@ -1,44 +0,0 @@
-import {spawn} from 'node:child_process';
-import {once} from 'node:events';
-import process from 'node:process';
-import {applyForceShell} from './windows.js';
-import {getResultError} from './result.js';
-
-export const spawnSubprocess = async (file, commandArguments, options, context) => {
-	try {
-		// When running `node`, keep the current Node version and CLI flags.
-		// Not applied with file paths to `.../node` since those indicate a clear intent to use a specific Node version.
-		// This also provides a way to opting out, e.g. using `process.execPath` instead of `node` to discard current CLI flags.
-		// Does not work with shebangs, but those don't work cross-platform anyway.
-		[file, commandArguments] = ['node', 'node.exe'].includes(file.toLowerCase())
-			? [process.execPath, [...process.execArgv.filter(flag => !flag.startsWith('--inspect')), ...commandArguments]]
-			: [file, commandArguments];
-
-		const instance = spawn(...await applyForceShell(file, commandArguments, options));
-		bufferOutput(instance.stdout, context, 'stdout');
-		bufferOutput(instance.stderr, context, 'stderr');
-
-		// The `error` event is caught by `once(instance, 'spawn')` and `once(instance, 'close')`.
-		// But it creates an uncaught exception if it happens exactly one tick after 'spawn'.
-		// This prevents that.
-		instance.once('error', () => {});
-
-		await once(instance, 'spawn');
-		return instance;
-	} catch (error) {
-		throw getResultError(error, {}, context);
-	}
-};
-
-const bufferOutput = (stream, {state}, streamName) => {
-	if (stream) {
-		stream.setEncoding('utf8');
-		if (!state.isIterating) {
-			state.isIterating = false;
-			stream.on('data', chunk => {
-				state[streamName] += chunk;
-				state.output += chunk;
-			});
-		}
-	}
-};

package/.output/server/node_modules/nano-spawn/source/windows.js

@@ -1,76 +0,0 @@
-import {stat} from 'node:fs/promises';
-import path from 'node:path';
-import process from 'node:process';
-
-// When setting `shell: true` under-the-hood, we must manually escape the file and arguments.
-// This ensures arguments are properly split, and prevents command injection.
-export const applyForceShell = async (file, commandArguments, options) => await shouldForceShell(file, options)
-	? [escapeFile(file), commandArguments.map(argument => escapeArgument(argument)), {...options, shell: true}]
-	: [file, commandArguments, options];
-
-// On Windows, running most executable files (except *.exe and *.com) requires using a shell.
-// This includes *.cmd and *.bat, which itself includes Node modules binaries.
-// We detect this situation and automatically:
-//  - Set the `shell: true` option
-//  - Escape shell-specific characters
-const shouldForceShell = async (file, {shell, cwd, env = process.env}) => process.platform === 'win32'
-	&& !shell
-	&& !(await isExe(file, cwd, env));
-
-// Detect whether the executable file is a *.exe or *.com file.
-// Windows allows omitting file extensions (present in the `PATHEXT` environment variable).
-// Therefore we must use the `PATH` environment variable and make `stat` calls to check this.
-// Environment variables are case-insensitive on Windows, so we check both `PATH` and `Path`.
-// eslint-disable-next-line no-return-assign
-const isExe = async (file, cwd, {Path = '', PATH = Path}) =>
-	// If the *.exe or *.com file extension was not omitted.
-	// Windows common file systems are case-insensitive.
-	exeExtensions.some(extension => file.toLowerCase().endsWith(extension))
-	// Use returned assignment to keep code small
-	|| (EXE_MEMO[`${file}\0${cwd}\0${PATH}`] ??= await mIsExe(file, cwd, PATH));
-
-// Memoize the following function, for performance
-const EXE_MEMO = {};
-
-const mIsExe = async (file, cwd, PATH) => {
-	const parts = PATH
-		// `PATH` is ;-separated on Windows
-		.split(path.delimiter)
-		// `PATH` allows leading/trailing ; on Windows
-		.filter(Boolean)
-		// `PATH` parts can be double quoted on Windows
-		.map(part => part.replace(/^"(.*)"$/, '$1'));
-
-	// For performance, parallelize and stop iteration as soon as an *.exe of *.com file is found
-	try {
-		await Promise.all(exeExtensions
-			.flatMap(extension =>
-				[cwd, ...parts].map(part => `${path.resolve(part, file)}${extension}`))
-			.map(async possibleFile => {
-				try {
-					await stat(possibleFile);
-				} catch {
-					return;
-				}
-
-				// eslint-disable-next-line no-throw-literal
-				throw 0;
-			}));
-	} catch {
-		return true;
-	}
-
-	return false;
-};
-
-// Other file extensions require using a shell
-const exeExtensions = ['.exe', '.com'];
-
-// `cmd.exe` escaping for arguments.
-// Taken from https://github.com/moxystudio/node-cross-spawn
-const escapeArgument = argument => escapeFile(escapeFile(`"${argument
-	.replaceAll(/(\\*)"/g, '$1$1\\"')
-	.replace(/(\\*)$/, '$1$1')}"`));
-
-// `cmd.exe` escaping for file and arguments.
-const escapeFile = file => file.replaceAll(/([()\][%!^"`<>&|;, *?])/g, '^$1');

package/.output/server/node_modules/node-gyp-build/index.js

@@ -1,6 +0,0 @@
-const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require // eslint-disable-line
-if (typeof runtimeRequire.addon === 'function') { // if the platform supports native resolving prefer that
-  module.exports = runtimeRequire.addon.bind(runtimeRequire)
-} else { // else use the runtime version here
-  module.exports = require('./node-gyp-build.js')
-}