@highstate/designer 0.2.1 → 0.2.2

package/.output/server/node_modules/path-key/index.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const pathKey = (options = {}) => {
-	const environment = options.env || process.env;
-	const platform = options.platform || process.platform;
-
-	if (platform !== 'win32') {
-		return 'PATH';
-	}
-
-	return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
-};
-
-module.exports = pathKey;
-// TODO: Remove this for the next major release
-module.exports.default = pathKey;

package/.output/server/node_modules/path-key/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "path-key",
-  "version": "3.1.1",
-  "description": "Get the PATH environment variable key cross-platform",
-  "license": "MIT",
-  "repository": "sindresorhus/path-key",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "sindresorhus.com"
-  },
-  "engines": {
-    "node": ">=8"
-  },
-  "scripts": {
-    "test": "xo && ava && tsd"
-  },
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "keywords": [
-    "path",
-    "key",
-    "environment",
-    "env",
-    "variable",
-    "var",
-    "get",
-    "cross-platform",
-    "windows"
-  ],
-  "devDependencies": {
-    "@types/node": "^11.13.0",
-    "ava": "^1.4.1",
-    "tsd": "^0.7.2",
-    "xo": "^0.24.0"
-  }
-}

package/.output/server/node_modules/pathe/dist/index.mjs

@@ -1 +0,0 @@
-export { h as basename, p as default, d as delimiter, f as dirname, e as extname, g as format, i as isAbsolute, j as join, a as normalize, b as normalizeString, k as parse, c as relative, r as resolve, s as sep, t as toNamespacedPath } from './shared/pathe.ff20891b.mjs';

package/.output/server/node_modules/pathe/dist/shared/pathe.ff20891b.mjs

@@ -1,221 +0,0 @@
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-const sep = "/";
-const delimiter = ":";
-const normalize = function(path) {
-  if (path.length === 0) {
-    return ".";
-  }
-  path = normalizeWindowsPath(path);
-  const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path[path.length - 1] === "/";
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path += "/";
-  }
-  if (_DRIVE_LETTER_RE.test(path)) {
-    path += "/";
-  }
-  if (isUNCPath) {
-    if (!isPathAbsolute) {
-      return `//./${path}`;
-    }
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-const join = function(...arguments_) {
-  if (arguments_.length === 0) {
-    return ".";
-  }
-  let joined;
-  for (const argument of arguments_) {
-    if (argument && argument.length > 0) {
-      if (joined === void 0) {
-        joined = argument;
-      } else {
-        joined += `/${argument}`;
-      }
-    }
-  }
-  if (joined === void 0) {
-    return ".";
-  }
-  return normalize(joined.replace(/\/\/+/g, "/"));
-};
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-const resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const toNamespacedPath = function(p) {
-  return normalizeWindowsPath(p);
-};
-const _EXTNAME_RE = /.(\.[^./]+)$/;
-const extname = function(p) {
-  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
-  return match && match[1] || "";
-};
-const relative = function(from, to) {
-  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
-    return _to.join("/");
-  }
-  const _fromCopy = [..._from];
-  for (const segment of _fromCopy) {
-    if (_to[0] !== segment) {
-      break;
-    }
-    _from.shift();
-    _to.shift();
-  }
-  return [..._from.map(() => ".."), ..._to].join("/");
-};
-const dirname = function(p) {
-  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
-    segments[0] += "/";
-  }
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-const format = function(p) {
-  const segments = [p.root, p.dir, p.base ?? p.name + p.ext].filter(Boolean);
-  return normalizeWindowsPath(
-    p.root ? resolve(...segments) : segments.join("/")
-  );
-};
-const basename = function(p, extension) {
-  const lastSegment = normalizeWindowsPath(p).split("/").pop();
-  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-};
-const parse = function(p) {
-  const root = normalizeWindowsPath(p).split("/").shift() || "/";
-  const base = basename(p);
-  const extension = extname(base);
-  return {
-    root,
-    dir: dirname(p),
-    base,
-    ext: extension,
-    name: base.slice(0, base.length - extension.length)
-  };
-};
-
-const path = {
-  __proto__: null,
-  basename: basename,
-  delimiter: delimiter,
-  dirname: dirname,
-  extname: extname,
-  format: format,
-  isAbsolute: isAbsolute,
-  join: join,
-  normalize: normalize,
-  normalizeString: normalizeString,
-  parse: parse,
-  relative: relative,
-  resolve: resolve,
-  sep: sep,
-  toNamespacedPath: toNamespacedPath
-};
-
-export { normalize as a, normalizeString as b, relative as c, delimiter as d, extname as e, dirname as f, format as g, basename as h, isAbsolute as i, join as j, parse as k, normalizeWindowsPath as n, path as p, resolve as r, sep as s, toNamespacedPath as t };

package/.output/server/node_modules/pathe/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "pathe",
-  "version": "1.1.2",
-  "description": "Universal filesystem path utils",
-  "repository": "unjs/pathe",
-  "license": "MIT",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    },
-    "./utils": {
-      "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.mjs",
-      "require": "./dist/utils.cjs"
-    }
-  },
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "utils.d.ts"
-  ],
-  "devDependencies": {
-    "@types/node": "^20.10.8",
-    "@vitest/coverage-v8": "^1.1.3",
-    "changelogen": "^0.5.5",
-    "eslint": "^8.56.0",
-    "eslint-config-unjs": "^0.2.1",
-    "jiti": "^1.21.0",
-    "prettier": "^3.1.1",
-    "typescript": "^5.3.3",
-    "unbuild": "^2.0.0",
-    "vitest": "^1.1.3"
-  },
-  "packageManager": "pnpm@8.14.0",
-  "scripts": {
-    "build": "unbuild",
-    "dev": "vitest",
-    "lint": "eslint --ext .ts . && prettier -c src test",
-    "lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
-    "release": "pnpm test && pnpm build && changelogen --release && pnpm publish && git push --follow-tags",
-    "test": "pnpm lint && vitest run --coverage",
-    "test:types": "tsc --noEmit"
-  }
-}

package/.output/server/node_modules/pkg-types/dist/index.mjs

@@ -1,156 +0,0 @@
-import { statSync, promises } from 'node:fs';
-import { resolve, join, isAbsolute, dirname } from 'pathe';
-import { resolvePath } from 'mlly';
-import { parseJSON, parseJSONC, stringifyJSON, stringifyJSONC } from 'confbox';
-
-const defaultFindOptions = {
-  startingFrom: ".",
-  rootPattern: /^node_modules$/,
-  reverse: false,
-  test: (filePath) => {
-    try {
-      if (statSync(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-    }
-  }
-};
-async function findFile(filename, _options = {}) {
-  const filenames = Array.isArray(filename) ? filename : [filename];
-  const options = { ...defaultFindOptions, ..._options };
-  const basePath = resolve(options.startingFrom);
-  const leadingSlash = basePath[0] === "/";
-  const segments = basePath.split("/").filter(Boolean);
-  if (leadingSlash) {
-    segments[0] = "/" + segments[0];
-  }
-  let root = segments.findIndex((r) => r.match(options.rootPattern));
-  if (root === -1) {
-    root = 0;
-  }
-  if (options.reverse) {
-    for (let index = root + 1; index <= segments.length; index++) {
-      for (const filename2 of filenames) {
-        const filePath = join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  } else {
-    for (let index = segments.length; index > root; index--) {
-      for (const filename2 of filenames) {
-        const filePath = join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  }
-  throw new Error(
-    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
-  );
-}
-function findNearestFile(filename, _options = {}) {
-  return findFile(filename, _options);
-}
-function findFarthestFile(filename, _options = {}) {
-  return findFile(filename, { ..._options, reverse: true });
-}
-
-function definePackageJSON(package_) {
-  return package_;
-}
-function defineTSConfig(tsconfig) {
-  return tsconfig;
-}
-const FileCache = /* @__PURE__ */ new Map();
-async function readPackageJSON(id, options = {}) {
-  const resolvedPath = await resolvePackageJSON(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  try {
-    parsed = parseJSON(blob);
-  } catch {
-    parsed = parseJSONC(blob);
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
-}
-async function writePackageJSON(path, package_) {
-  await promises.writeFile(path, stringifyJSON(package_));
-}
-async function readTSConfig(id, options = {}) {
-  const resolvedPath = await resolveTSConfig(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const text = await promises.readFile(resolvedPath, "utf8");
-  const parsed = parseJSONC(text);
-  cache.set(resolvedPath, parsed);
-  return parsed;
-}
-async function writeTSConfig(path, tsconfig) {
-  await promises.writeFile(path, stringifyJSONC(tsconfig));
-}
-async function resolvePackageJSON(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  return findNearestFile("package.json", {
-    startingFrom: resolvedPath,
-    ...options
-  });
-}
-async function resolveTSConfig(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  return findNearestFile("tsconfig.json", {
-    startingFrom: resolvedPath,
-    ...options
-  });
-}
-const lockFiles = [
-  "yarn.lock",
-  "package-lock.json",
-  "pnpm-lock.yaml",
-  "npm-shrinkwrap.json",
-  "bun.lockb"
-];
-async function resolveLockfile(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  const _options = { startingFrom: resolvedPath, ...options };
-  try {
-    return await findNearestFile(lockFiles, _options);
-  } catch {
-  }
-  throw new Error("No lockfile found from " + id);
-}
-async function findWorkspaceDir(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  const _options = { startingFrom: resolvedPath, ...options };
-  try {
-    const r = await findNearestFile(".git/config", _options);
-    return resolve(r, "../..");
-  } catch {
-  }
-  try {
-    const r = await resolveLockfile(resolvedPath, {
-      ..._options,
-      reverse: true
-    });
-    return dirname(r);
-  } catch {
-  }
-  try {
-    const r = await findFile(resolvedPath, _options);
-    return dirname(r);
-  } catch {
-  }
-  throw new Error("Cannot detect workspace root from " + id);
-}
-
-export { definePackageJSON, defineTSConfig, findFarthestFile, findFile, findNearestFile, findWorkspaceDir, readPackageJSON, readTSConfig, resolveLockfile, resolvePackageJSON, resolveTSConfig, writePackageJSON, writeTSConfig };

package/.output/server/node_modules/pkg-types/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "pkg-types",
-  "version": "1.2.1",
-  "description": "Node.js utilities and TypeScript definitions for `package.json` and `tsconfig.json`",
-  "license": "MIT",
-  "main": "./dist/index.cjs",
-  "sideEffects": false,
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.cjs"
-  },
-  "types": "./dist/index.d.ts",
-  "repository": "unjs/pkg-types",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "unbuild",
-    "prepack": "pnpm build",
-    "dev": "vitest --typecheck",
-    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
-    "lint": "eslint && prettier -c src test",
-    "lint:fix": "automd && eslint --fix . && prettier -w src test",
-    "test": "vitest run --typecheck --coverage"
-  },
-  "dependencies": {
-    "confbox": "^0.1.8",
-    "mlly": "^1.7.2",
-    "pathe": "^1.1.2"
-  },
-  "devDependencies": {
-    "@types/node": "^22.7.5",
-    "@vitest/coverage-v8": "^2.1.2",
-    "automd": "^0.3.10",
-    "changelogen": "^0.5.7",
-    "eslint": "^9.12.0",
-    "eslint-config-unjs": "^0.4.1",
-    "expect-type": "^1.0.0",
-    "jiti": "^2.3.3",
-    "prettier": "^3.3.3",
-    "typescript": "^5.6.2",
-    "unbuild": "^2.0.0",
-    "vitest": "^2.1.2"
-  },
-  "packageManager": "pnpm@9.12.1"
-}

package/.output/server/node_modules/promise-make-counter/dist/index.js

@@ -1,24 +0,0 @@
-/* IMPORT */
-import makeNakedPromise from 'promise-make-naked';
-/* MAIN */
-const makeCounterPromise = () => {
-    const { promise, resolve, isPending } = makeNakedPromise();
-    let counter = 0;
-    const increment = () => {
-        counter += 1;
-    };
-    const decrement = () => {
-        counter -= 1;
-        if (counter)
-            return;
-        resolve();
-    };
-    const init = () => {
-        increment();
-        queueMicrotask(decrement);
-    };
-    init();
-    return { promise, isPending, increment, decrement };
-};
-/* EXPORT */
-export default makeCounterPromise;

package/.output/server/node_modules/promise-make-counter/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "promise-make-counter",
-  "repository": "github:fabiospampinato/promise-make-counter",
-  "description": "A simple function that makes a counter-based promise, which can be incremented and decremented, and it resolves once its counter reaches zero.",
-  "version": "1.0.1",
-  "type": "module",
-  "main": "dist/index.js",
-  "exports": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "clean": "tsex clean",
-    "compile": "tsex compile",
-    "compile:watch": "tsex compile --watch",
-    "test": "tsex test",
-    "test:watch": "tsex test --watch",
-    "prepublishOnly": "tsex prepare"
-  },
-  "keywords": [
-    "promise",
-    "make",
-    "counter",
-    "reference"
-  ],
-  "dependencies": {
-    "promise-make-naked": "^3.0.0"
-  },
-  "devDependencies": {
-    "fava": "^0.3.4",
-    "tsex": "^4.0.2",
-    "typescript": "^5.5.0-beta"
-  }
-}

package/.output/server/node_modules/promise-make-naked/dist/index.js

@@ -1,25 +0,0 @@
-/* IMPORT */
-import { noop } from './utils.js';
-/* MAIN */
-const makeNakedPromise = () => {
-    let resolve = noop;
-    let reject = noop;
-    let resolved = false;
-    let rejected = false;
-    const promise = new Promise((res, rej) => {
-        resolve = value => {
-            resolved = true;
-            return res(value);
-        };
-        reject = value => {
-            rejected = true;
-            return rej(value);
-        };
-    });
-    const isPending = () => !resolved && !rejected;
-    const isResolved = () => resolved;
-    const isRejected = () => rejected;
-    return { promise, resolve, reject, isPending, isResolved, isRejected };
-};
-/* EXPORT */
-export default makeNakedPromise;

package/.output/server/node_modules/promise-make-naked/dist/utils.js

@@ -1,4 +0,0 @@
-/* MAIN */
-const noop = () => { };
-/* EXPORT */
-export { noop };

package/.output/server/node_modules/promise-make-naked/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "promise-make-naked",
-  "repository": "github:fabiospampinato/promise-make-naked",
-  "description": "A simple function that makes a promise that can be resolved, rejected or introspected from the outside.",
-  "version": "3.0.0",
-  "type": "module",
-  "main": "dist/index.js",
-  "exports": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "clean": "tsex clean",
-    "compile": "tsex compile",
-    "compile:watch": "tsex compile --watch",
-    "test": "tsex test",
-    "test:watch": "tsex test --watch",
-    "prepublishOnly": "tsex prepare"
-  },
-  "keywords": [
-    "promise",
-    "naked"
-  ],
-  "devDependencies": {
-    "fava": "^0.3.2",
-    "tsex": "^4.0.2",
-    "typescript": "^5.5.2"
-  }
-}