@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/execa/lib/stdio.js

@@ -0,0 +1,52 @@
+'use strict';
+const aliases = ['stdin', 'stdout', 'stderr'];
+
+const hasAlias = options => aliases.some(alias => options[alias] !== undefined);
+
+const normalizeStdio = options => {
+	if (!options) {
+		return;
+	}
+
+	const {stdio} = options;
+
+	if (stdio === undefined) {
+		return aliases.map(alias => options[alias]);
+	}
+
+	if (hasAlias(options)) {
+		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
+	}
+
+	if (typeof stdio === 'string') {
+		return stdio;
+	}
+
+	if (!Array.isArray(stdio)) {
+		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+	}
+
+	const length = Math.max(stdio.length, aliases.length);
+	return Array.from({length}, (value, index) => stdio[index]);
+};
+
+module.exports = normalizeStdio;
+
+// `ipc` is pushed unless it is already present
+module.exports.node = options => {
+	const stdio = normalizeStdio(options);
+
+	if (stdio === 'ipc') {
+		return 'ipc';
+	}
+
+	if (stdio === undefined || typeof stdio === 'string') {
+		return [stdio, stdio, stdio, 'ipc'];
+	}
+
+	if (stdio.includes('ipc')) {
+		return stdio;
+	}
+
+	return [...stdio, 'ipc'];
+};

package/.output/server/node_modules/execa/lib/stream.js

@@ -0,0 +1,97 @@
+'use strict';
+const isStream = require('is-stream');
+const getStream = require('get-stream');
+const mergeStream = require('merge-stream');
+
+// `input` option
+const handleInput = (spawned, input) => {
+	// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
+	// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
+	if (input === undefined || spawned.stdin === undefined) {
+		return;
+	}
+
+	if (isStream(input)) {
+		input.pipe(spawned.stdin);
+	} else {
+		spawned.stdin.end(input);
+	}
+};
+
+// `all` interleaves `stdout` and `stderr`
+const makeAllStream = (spawned, {all}) => {
+	if (!all || (!spawned.stdout && !spawned.stderr)) {
+		return;
+	}
+
+	const mixed = mergeStream();
+
+	if (spawned.stdout) {
+		mixed.add(spawned.stdout);
+	}
+
+	if (spawned.stderr) {
+		mixed.add(spawned.stderr);
+	}
+
+	return mixed;
+};
+
+// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
+const getBufferedData = async (stream, streamPromise) => {
+	if (!stream) {
+		return;
+	}
+
+	stream.destroy();
+
+	try {
+		return await streamPromise;
+	} catch (error) {
+		return error.bufferedData;
+	}
+};
+
+const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
+	if (!stream || !buffer) {
+		return;
+	}
+
+	if (encoding) {
+		return getStream(stream, {encoding, maxBuffer});
+	}
+
+	return getStream.buffer(stream, {maxBuffer});
+};
+
+// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
+const getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
+	const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
+	const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
+	const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
+
+	try {
+		return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+	} catch (error) {
+		return Promise.all([
+			{error, signal: error.signal, timedOut: error.timedOut},
+			getBufferedData(stdout, stdoutPromise),
+			getBufferedData(stderr, stderrPromise),
+			getBufferedData(all, allPromise)
+		]);
+	}
+};
+
+const validateInputSync = ({input}) => {
+	if (isStream(input)) {
+		throw new TypeError('The `input` option cannot be a stream in sync mode');
+	}
+};
+
+module.exports = {
+	handleInput,
+	makeAllStream,
+	getSpawnedResult,
+	validateInputSync
+};
+

package/.output/server/node_modules/execa/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "execa",
+  "version": "5.1.1",
+  "description": "Process execution for humans",
+  "license": "MIT",
+  "repository": "sindresorhus/execa",
+  "funding": "https://github.com/sindresorhus/execa?sponsor=1",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "test": "xo && nyc ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib"
+  ],
+  "keywords": [
+    "exec",
+    "child",
+    "process",
+    "execute",
+    "fork",
+    "execfile",
+    "spawn",
+    "file",
+    "shell",
+    "bin",
+    "binary",
+    "binaries",
+    "npm",
+    "path",
+    "local"
+  ],
+  "dependencies": {
+    "cross-spawn": "^7.0.3",
+    "get-stream": "^6.0.0",
+    "human-signals": "^2.1.0",
+    "is-stream": "^2.0.0",
+    "merge-stream": "^2.0.0",
+    "npm-run-path": "^4.0.1",
+    "onetime": "^5.1.2",
+    "signal-exit": "^3.0.3",
+    "strip-final-newline": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^14.14.10",
+    "ava": "^2.4.0",
+    "get-node": "^11.0.1",
+    "is-running": "^2.1.0",
+    "nyc": "^15.1.0",
+    "p-event": "^4.2.0",
+    "tempfile": "^3.0.0",
+    "tsd": "^0.13.1",
+    "xo": "^0.35.0"
+  },
+  "nyc": {
+    "reporter": [
+      "text",
+      "lcov"
+    ],
+    "exclude": [
+      "**/fixtures/**",
+      "**/test.js",
+      "**/test/**"
+    ]
+  }
+}

package/.output/server/node_modules/fast-deep-equal/index.js

@@ -0,0 +1,46 @@
+'use strict';
+
+// do not edit .js files directly - edit src/index.jst
+
+
+
+module.exports = function equal(a, b) {
+  if (a === b) return true;
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    if (a.constructor !== b.constructor) return false;
+
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (!equal(a[i], b[i])) return false;
+      return true;
+    }
+
+
+
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) return false;
+
+    for (i = length; i-- !== 0;)
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+    for (i = length; i-- !== 0;) {
+      var key = keys[i];
+
+      if (!equal(a[key], b[key])) return false;
+    }
+
+    return true;
+  }
+
+  // true if both NaN, false otherwise
+  return a!==a && b!==b;
+};

package/.output/server/node_modules/fast-deep-equal/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "fast-deep-equal",
+  "version": "3.1.3",
+  "description": "Fast deep equal",
+  "main": "index.js",
+  "scripts": {
+    "eslint": "eslint *.js benchmark/*.js spec/*.js",
+    "build": "node build",
+    "benchmark": "npm i && npm run build && cd ./benchmark && npm i && node ./",
+    "test-spec": "mocha spec/*.spec.js -R spec",
+    "test-cov": "nyc npm run test-spec",
+    "test-ts": "tsc --target ES5 --noImplicitAny index.d.ts",
+    "test": "npm run build && npm run eslint && npm run test-ts && npm run test-cov",
+    "prepublish": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/epoberezkin/fast-deep-equal.git"
+  },
+  "keywords": [
+    "fast",
+    "equal",
+    "deep-equal"
+  ],
+  "author": "Evgeny Poberezkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/epoberezkin/fast-deep-equal/issues"
+  },
+  "homepage": "https://github.com/epoberezkin/fast-deep-equal#readme",
+  "devDependencies": {
+    "coveralls": "^3.1.0",
+    "dot": "^1.1.2",
+    "eslint": "^7.2.0",
+    "mocha": "^7.2.0",
+    "nyc": "^15.1.0",
+    "pre-commit": "^1.2.2",
+    "react": "^16.12.0",
+    "react-test-renderer": "^16.12.0",
+    "sinon": "^9.0.2",
+    "typescript": "^3.9.5"
+  },
+  "nyc": {
+    "exclude": [
+      "**/spec/**",
+      "node_modules"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "react.js",
+    "react.d.ts",
+    "es6/"
+  ],
+  "types": "index.d.ts"
+}

package/.output/server/node_modules/fast-redact/index.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const validator = require('./lib/validator')
+const parse = require('./lib/parse')
+const redactor = require('./lib/redactor')
+const restorer = require('./lib/restorer')
+const { groupRedact, nestedRedact } = require('./lib/modifiers')
+const state = require('./lib/state')
+const rx = require('./lib/rx')
+const validate = validator()
+const noop = (o) => o
+noop.restore = noop
+
+const DEFAULT_CENSOR = '[REDACTED]'
+fastRedact.rx = rx
+fastRedact.validator = validator
+
+module.exports = fastRedact
+
+function fastRedact (opts = {}) {
+  const paths = Array.from(new Set(opts.paths || []))
+  const serialize = 'serialize' in opts ? (
+    opts.serialize === false ? opts.serialize
+      : (typeof opts.serialize === 'function' ? opts.serialize : JSON.stringify)
+  ) : JSON.stringify
+  const remove = opts.remove
+  if (remove === true && serialize !== JSON.stringify) {
+    throw Error('fast-redact – remove option may only be set when serializer is JSON.stringify')
+  }
+  const censor = remove === true
+    ? undefined
+    : 'censor' in opts ? opts.censor : DEFAULT_CENSOR
+
+  const isCensorFct = typeof censor === 'function'
+  const censorFctTakesPath = isCensorFct && censor.length > 1
+
+  if (paths.length === 0) return serialize || noop
+
+  validate({ paths, serialize, censor })
+
+  const { wildcards, wcLen, secret } = parse({ paths, censor })
+
+  const compileRestore = restorer()
+  const strict = 'strict' in opts ? opts.strict : true
+
+  return redactor({ secret, wcLen, serialize, strict, isCensorFct, censorFctTakesPath }, state({
+    secret,
+    censor,
+    compileRestore,
+    serialize,
+    groupRedact,
+    nestedRedact,
+    wildcards,
+    wcLen
+  }))
+}

package/.output/server/node_modules/fast-redact/lib/modifiers.js

@@ -0,0 +1,291 @@
+'use strict'
+
+module.exports = {
+  groupRedact,
+  groupRestore,
+  nestedRedact,
+  nestedRestore
+}
+
+function groupRestore ({ keys, values, target }) {
+  if (target == null || typeof target === 'string') return
+  const length = keys.length
+  for (var i = 0; i < length; i++) {
+    const k = keys[i]
+    target[k] = values[i]
+  }
+}
+
+function groupRedact (o, path, censor, isCensorFct, censorFctTakesPath) {
+  const target = get(o, path)
+  if (target == null || typeof target === 'string') return { keys: null, values: null, target, flat: true }
+  const keys = Object.keys(target)
+  const keysLength = keys.length
+  const pathLength = path.length
+  const pathWithKey = censorFctTakesPath ? [...path] : undefined
+  const values = new Array(keysLength)
+
+  for (var i = 0; i < keysLength; i++) {
+    const key = keys[i]
+    values[i] = target[key]
+
+    if (censorFctTakesPath) {
+      pathWithKey[pathLength] = key
+      target[key] = censor(target[key], pathWithKey)
+    } else if (isCensorFct) {
+      target[key] = censor(target[key])
+    } else {
+      target[key] = censor
+    }
+  }
+  return { keys, values, target, flat: true }
+}
+
+/**
+ * @param {RestoreInstruction[]} instructions a set of instructions for restoring values to objects
+ */
+function nestedRestore (instructions) {
+  for (let i = 0; i < instructions.length; i++) {
+    const { target, path, value } = instructions[i]
+    let current = target
+    for (let i = path.length - 1; i > 0; i--) {
+      current = current[path[i]]
+    }
+    current[path[0]] = value
+  }
+}
+
+function nestedRedact (store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
+  const target = get(o, path)
+  if (target == null) return
+  const keys = Object.keys(target)
+  const keysLength = keys.length
+  for (var i = 0; i < keysLength; i++) {
+    const key = keys[i]
+    specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath)
+  }
+  return store
+}
+
+function has (obj, prop) {
+  return obj !== undefined && obj !== null
+    ? ('hasOwn' in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop))
+    : false
+}
+
+function specialSet (store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
+  const afterPathLen = afterPath.length
+  const lastPathIndex = afterPathLen - 1
+  const originalKey = k
+  var i = -1
+  var n
+  var nv
+  var ov
+  var oov = null
+  var wc = null
+  var kIsWc
+  var wcov
+  var consecutive = false
+  var level = 0
+  // need to track depth of the `redactPath` tree
+  var depth = 0
+  var redactPathCurrent = tree()
+  ov = n = o[k]
+  if (typeof n !== 'object') return
+  while (n != null && ++i < afterPathLen) {
+    depth += 1
+    k = afterPath[i]
+    oov = ov
+    if (k !== '*' && !wc && !(typeof n === 'object' && k in n)) {
+      break
+    }
+    if (k === '*') {
+      if (wc === '*') {
+        consecutive = true
+      }
+      wc = k
+      if (i !== lastPathIndex) {
+        continue
+      }
+    }
+    if (wc) {
+      const wcKeys = Object.keys(n)
+      for (var j = 0; j < wcKeys.length; j++) {
+        const wck = wcKeys[j]
+        wcov = n[wck]
+        kIsWc = k === '*'
+        if (consecutive) {
+          redactPathCurrent = node(redactPathCurrent, wck, depth)
+          level = i
+          ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1)
+        } else {
+          if (kIsWc || (typeof wcov === 'object' && wcov !== null && k in wcov)) {
+            if (kIsWc) {
+              ov = wcov
+            } else {
+              ov = wcov[k]
+            }
+            nv = (i !== lastPathIndex)
+              ? ov
+              : (isCensorFct
+                ? (censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov))
+                : censor)
+            if (kIsWc) {
+              const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey])
+              store.push(rv)
+              n[wck] = nv
+            } else {
+              if (wcov[k] === nv) {
+                // pass
+              } else if ((nv === undefined && censor !== undefined) || (has(wcov, k) && nv === ov)) {
+                redactPathCurrent = node(redactPathCurrent, wck, depth)
+              } else {
+                redactPathCurrent = node(redactPathCurrent, wck, depth)
+                const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey])
+                store.push(rv)
+                wcov[k] = nv
+              }
+            }
+          }
+        }
+      }
+      wc = null
+    } else {
+      ov = n[k]
+      redactPathCurrent = node(redactPathCurrent, k, depth)
+      nv = (i !== lastPathIndex)
+        ? ov
+        : (isCensorFct
+          ? (censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov))
+          : censor)
+      if ((has(n, k) && nv === ov) || (nv === undefined && censor !== undefined)) {
+        // pass
+      } else {
+        const rv = restoreInstr(redactPathCurrent, ov, o[originalKey])
+        store.push(rv)
+        n[k] = nv
+      }
+      n = n[k]
+    }
+    if (typeof n !== 'object') break
+    // prevent circular structure, see https://github.com/pinojs/pino/issues/1513
+    if (ov === oov || typeof ov === 'undefined') {
+      // pass
+    }
+  }
+}
+
+function get (o, p) {
+  var i = -1
+  var l = p.length
+  var n = o
+  while (n != null && ++i < l) {
+    n = n[p[i]]
+  }
+  return n
+}
+
+function iterateNthLevel (wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
+  if (level === 0) {
+    if (kIsWc || (typeof wcov === 'object' && wcov !== null && k in wcov)) {
+      if (kIsWc) {
+        ov = wcov
+      } else {
+        ov = wcov[k]
+      }
+      nv = (i !== lastPathIndex)
+        ? ov
+        : (isCensorFct
+          ? (censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov))
+          : censor)
+      if (kIsWc) {
+        const rv = restoreInstr(redactPathCurrent, ov, parent)
+        store.push(rv)
+        n[wck] = nv
+      } else {
+        if (wcov[k] === nv) {
+          // pass
+        } else if ((nv === undefined && censor !== undefined) || (has(wcov, k) && nv === ov)) {
+          // pass
+        } else {
+          const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent)
+          store.push(rv)
+          wcov[k] = nv
+        }
+      }
+    }
+  }
+  for (const key in wcov) {
+    if (typeof wcov[key] === 'object') {
+      redactPathCurrent = node(redactPathCurrent, key, depth)
+      iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1)
+    }
+  }
+}
+
+/**
+ * @typedef {object} TreeNode
+ * @prop {TreeNode} [parent] reference to the parent of this node in the tree, or `null` if there is no parent
+ * @prop {string} key the key that this node represents (key here being part of the path being redacted
+ * @prop {TreeNode[]} children the child nodes of this node
+ * @prop {number} depth the depth of this node in the tree
+ */
+
+/**
+ * instantiate a new, empty tree
+ * @returns {TreeNode}
+ */
+function tree () {
+  return { parent: null, key: null, children: [], depth: 0 }
+}
+
+/**
+ * creates a new node in the tree, attaching it as a child of the provided parent node
+ * if the specified depth matches the parent depth, adds the new node as a _sibling_ of the parent instead
+  * @param {TreeNode} parent the parent node to add a new node to (if the parent depth matches the provided `depth` value, will instead add as a sibling of this
+  * @param {string} key the key that the new node represents (key here being part of the path being redacted)
+  * @param {number} depth the depth of the new node in the tree - used to determing whether to add the new node as a child or sibling of the provided `parent` node
+  * @returns {TreeNode} a reference to the newly created node in the tree
+ */
+function node (parent, key, depth) {
+  if (parent.depth === depth) {
+    return node(parent.parent, key, depth)
+  }
+
+  var child = {
+    parent,
+    key,
+    depth,
+    children: []
+  }
+
+  parent.children.push(child)
+
+  return child
+}
+
+/**
+ * @typedef {object} RestoreInstruction
+ * @prop {string[]} path a reverse-order path that can be used to find the correct insertion point to restore a `value` for the given `parent` object
+ * @prop {*} value the value to restore
+ * @prop {object} target the object to restore the `value` in
+ */
+
+/**
+ * create a restore instruction for the given redactPath node
+ * generates a path in reverse order by walking up the redactPath tree
+ * @param {TreeNode} node a tree node that should be at the bottom of the redact path (i.e. have no children) - this will be used to walk up the redact path tree to construct the path needed to restore
+ * @param {*} value the value to restore
+ * @param {object} target a reference to the parent object to apply the restore instruction to
+ * @returns {RestoreInstruction} an instruction used to restore a nested value for a specific object
+ */
+function restoreInstr (node, value, target) {
+  let current = node
+  const path = []
+  do {
+    path.push(current.key)
+    current = current.parent
+  } while (current.parent != null)
+
+  return { path, value, target }
+}