@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/sonic-boom/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "sonic-boom",
+  "version": "4.2.0",
+  "description": "Extremely fast utf8 only stream implementation",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "test": "npm run test:types && standard && npm run test:unit",
+    "test:unit": "tap",
+    "test:types": "tsc && tsd"
+  },
+  "pre-commit": [
+    "test"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/sonic-boom.git"
+  },
+  "keywords": [
+    "stream",
+    "fs",
+    "net",
+    "fd",
+    "file",
+    "descriptor",
+    "fast"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/sonic-boom/issues"
+  },
+  "homepage": "https://github.com/pinojs/sonic-boom#readme",
+  "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "@sinonjs/fake-timers": "^13.0.1",
+    "@types/node": "^22.0.0",
+    "fastbench": "^1.0.1",
+    "proxyquire": "^2.1.3",
+    "standard": "^17.0.0",
+    "tap": "^18.2.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.0.2"
+  },
+  "dependencies": {
+    "atomic-sleep": "^1.0.0"
+  },
+  "tsd": {
+    "directory": "./types"
+  }
+}

package/.output/server/node_modules/split2/index.js

@@ -0,0 +1,141 @@
+/*
+Copyright (c) 2014-2021, Matteo Collina <hello@matteocollina.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+'use strict'
+
+const { Transform } = require('stream')
+const { StringDecoder } = require('string_decoder')
+const kLast = Symbol('last')
+const kDecoder = Symbol('decoder')
+
+function transform (chunk, enc, cb) {
+  let list
+  if (this.overflow) { // Line buffer is full. Skip to start of next line.
+    const buf = this[kDecoder].write(chunk)
+    list = buf.split(this.matcher)
+
+    if (list.length === 1) return cb() // Line ending not found. Discard entire chunk.
+
+    // Line ending found. Discard trailing fragment of previous line and reset overflow state.
+    list.shift()
+    this.overflow = false
+  } else {
+    this[kLast] += this[kDecoder].write(chunk)
+    list = this[kLast].split(this.matcher)
+  }
+
+  this[kLast] = list.pop()
+
+  for (let i = 0; i < list.length; i++) {
+    try {
+      push(this, this.mapper(list[i]))
+    } catch (error) {
+      return cb(error)
+    }
+  }
+
+  this.overflow = this[kLast].length > this.maxLength
+  if (this.overflow && !this.skipOverflow) {
+    cb(new Error('maximum buffer reached'))
+    return
+  }
+
+  cb()
+}
+
+function flush (cb) {
+  // forward any gibberish left in there
+  this[kLast] += this[kDecoder].end()
+
+  if (this[kLast]) {
+    try {
+      push(this, this.mapper(this[kLast]))
+    } catch (error) {
+      return cb(error)
+    }
+  }
+
+  cb()
+}
+
+function push (self, val) {
+  if (val !== undefined) {
+    self.push(val)
+  }
+}
+
+function noop (incoming) {
+  return incoming
+}
+
+function split (matcher, mapper, options) {
+  // Set defaults for any arguments not supplied.
+  matcher = matcher || /\r?\n/
+  mapper = mapper || noop
+  options = options || {}
+
+  // Test arguments explicitly.
+  switch (arguments.length) {
+    case 1:
+      // If mapper is only argument.
+      if (typeof matcher === 'function') {
+        mapper = matcher
+        matcher = /\r?\n/
+      // If options is only argument.
+      } else if (typeof matcher === 'object' && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
+        options = matcher
+        matcher = /\r?\n/
+      }
+      break
+
+    case 2:
+      // If mapper and options are arguments.
+      if (typeof matcher === 'function') {
+        options = mapper
+        mapper = matcher
+        matcher = /\r?\n/
+      // If matcher and options are arguments.
+      } else if (typeof mapper === 'object') {
+        options = mapper
+        mapper = noop
+      }
+  }
+
+  options = Object.assign({}, options)
+  options.autoDestroy = true
+  options.transform = transform
+  options.flush = flush
+  options.readableObjectMode = true
+
+  const stream = new Transform(options)
+
+  stream[kLast] = ''
+  stream[kDecoder] = new StringDecoder('utf8')
+  stream.matcher = matcher
+  stream.mapper = mapper
+  stream.maxLength = options.maxLength
+  stream.skipOverflow = options.skipOverflow || false
+  stream.overflow = false
+  stream._destroy = function (err, cb) {
+    // Weird Node v12 bug that we need to work around
+    this._writableState.errorEmitted = false
+    cb(err)
+  }
+
+  return stream
+}
+
+module.exports = split

package/.output/server/node_modules/split2/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "split2",
+  "version": "4.2.0",
+  "description": "split a Text Stream into a Line Stream, using Stream 3",
+  "main": "index.js",
+  "scripts": {
+    "lint": "standard --verbose",
+    "unit": "nyc --lines 100 --branches 100 --functions 100 --check-coverage --reporter=text tape test.js",
+    "coverage": "nyc --reporter=html --reporter=cobertura --reporter=text tape test/test.js",
+    "test:report": "npm run lint && npm run unit:report",
+    "test": "npm run lint && npm run unit",
+    "legacy": "tape test.js"
+  },
+  "pre-commit": [
+    "test"
+  ],
+  "website": "https://github.com/mcollina/split2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mcollina/split2.git"
+  },
+  "bugs": {
+    "url": "http://github.com/mcollina/split2/issues"
+  },
+  "engines": {
+    "node": ">= 10.x"
+  },
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "ISC",
+  "devDependencies": {
+    "binary-split": "^1.0.3",
+    "callback-stream": "^1.1.0",
+    "fastbench": "^1.0.0",
+    "nyc": "^15.0.1",
+    "pre-commit": "^1.1.2",
+    "standard": "^17.0.0",
+    "tape": "^5.0.0"
+  }
+}

package/.output/server/node_modules/strip-final-newline/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = input => {
+	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
+	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
+
+	if (input[input.length - 1] === LF) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	if (input[input.length - 1] === CR) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	return input;
+};

package/.output/server/node_modules/strip-final-newline/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "strip-final-newline",
+  "version": "2.0.0",
+  "description": "Strip the final newline character from a string/buffer",
+  "license": "MIT",
+  "repository": "sindresorhus/strip-final-newline",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "test": "xo && ava"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "strip",
+    "trim",
+    "remove",
+    "delete",
+    "final",
+    "last",
+    "end",
+    "file",
+    "newline",
+    "linebreak",
+    "character",
+    "string",
+    "buffer"
+  ],
+  "devDependencies": {
+    "ava": "^0.25.0",
+    "xo": "^0.23.0"
+  }
+}

package/.output/server/node_modules/stubborn-fs/dist/attemptify.js

@@ -0,0 +1,19 @@
+/* MAIN */
+//FIXME: The return type of these functions is wrong, it doesn't account for returning "undefined", but a correct type cannot be written because generics cannot be extended properly, it seems
+const attemptifyAsync = (fn, onError) => {
+    return function attemptified(...args) {
+        return fn.apply(undefined, args).catch(onError);
+    };
+};
+const attemptifySync = (fn, onError) => {
+    return function attemptified(...args) {
+        try {
+            return fn.apply(undefined, args);
+        }
+        catch (error) {
+            return onError(error);
+        }
+    };
+};
+/* EXPORT */
+export { attemptifyAsync, attemptifySync };

package/.output/server/node_modules/stubborn-fs/dist/constants.js

@@ -0,0 +1,8 @@
+/* IMPORT */
+import process from 'node:process';
+/* MAIN */
+const IS_USER_ROOT = process.getuid ? !process.getuid() : false;
+const LIMIT_FILES_DESCRIPTORS = 10000; //TODO: Fetch the real limit from the filesystem, somehow
+const NOOP = () => undefined;
+/* EXPORT */
+export { IS_USER_ROOT, LIMIT_FILES_DESCRIPTORS, NOOP };

package/.output/server/node_modules/stubborn-fs/dist/handlers.js

@@ -0,0 +1,36 @@
+/* IMPORT */
+import { IS_USER_ROOT } from './constants.js';
+/* MAIN */
+const Handlers = {
+    /* API */
+    isChangeErrorOk: (error) => {
+        if (!Handlers.isNodeError(error))
+            return false;
+        const { code } = error;
+        if (code === 'ENOSYS')
+            return true;
+        if (!IS_USER_ROOT && (code === 'EINVAL' || code === 'EPERM'))
+            return true;
+        return false;
+    },
+    isNodeError: (error) => {
+        return (error instanceof Error);
+    },
+    isRetriableError: (error) => {
+        if (!Handlers.isNodeError(error))
+            return false;
+        const { code } = error;
+        if (code === 'EMFILE' || code === 'ENFILE' || code === 'EAGAIN' || code === 'EBUSY' || code === 'EACCESS' || code === 'EACCES' || code === 'EACCS' || code === 'EPERM')
+            return true;
+        return false;
+    },
+    onChangeError: (error) => {
+        if (!Handlers.isNodeError(error))
+            throw error;
+        if (Handlers.isChangeErrorOk(error))
+            return;
+        throw error;
+    }
+};
+/* EXPORT */
+export default Handlers;

package/.output/server/node_modules/stubborn-fs/dist/index.js

@@ -0,0 +1,53 @@
+/* IMPORT */
+import fs from 'node:fs';
+import { promisify } from 'node:util';
+import { attemptifyAsync, attemptifySync } from './attemptify.js';
+import { NOOP } from './constants.js';
+import Handlers from './handlers.js';
+import { retryifyAsync, retryifySync } from './retryify.js';
+/* MAIN */
+const FS = {
+    attempt: {
+        /* ASYNC */
+        chmod: attemptifyAsync(promisify(fs.chmod), Handlers.onChangeError),
+        chown: attemptifyAsync(promisify(fs.chown), Handlers.onChangeError),
+        close: attemptifyAsync(promisify(fs.close), NOOP),
+        fsync: attemptifyAsync(promisify(fs.fsync), NOOP),
+        mkdir: attemptifyAsync(promisify(fs.mkdir), NOOP),
+        realpath: attemptifyAsync(promisify(fs.realpath), NOOP),
+        stat: attemptifyAsync(promisify(fs.stat), NOOP),
+        unlink: attemptifyAsync(promisify(fs.unlink), NOOP),
+        /* SYNC */
+        chmodSync: attemptifySync(fs.chmodSync, Handlers.onChangeError),
+        chownSync: attemptifySync(fs.chownSync, Handlers.onChangeError),
+        closeSync: attemptifySync(fs.closeSync, NOOP),
+        existsSync: attemptifySync(fs.existsSync, NOOP),
+        fsyncSync: attemptifySync(fs.fsync, NOOP),
+        mkdirSync: attemptifySync(fs.mkdirSync, NOOP),
+        realpathSync: attemptifySync(fs.realpathSync, NOOP),
+        statSync: attemptifySync(fs.statSync, NOOP),
+        unlinkSync: attemptifySync(fs.unlinkSync, NOOP)
+    },
+    retry: {
+        /* ASYNC */
+        close: retryifyAsync(promisify(fs.close), Handlers.isRetriableError),
+        fsync: retryifyAsync(promisify(fs.fsync), Handlers.isRetriableError),
+        open: retryifyAsync(promisify(fs.open), Handlers.isRetriableError),
+        readFile: retryifyAsync(promisify(fs.readFile), Handlers.isRetriableError),
+        rename: retryifyAsync(promisify(fs.rename), Handlers.isRetriableError),
+        stat: retryifyAsync(promisify(fs.stat), Handlers.isRetriableError),
+        write: retryifyAsync(promisify(fs.write), Handlers.isRetriableError),
+        writeFile: retryifyAsync(promisify(fs.writeFile), Handlers.isRetriableError),
+        /* SYNC */
+        closeSync: retryifySync(fs.closeSync, Handlers.isRetriableError),
+        fsyncSync: retryifySync(fs.fsyncSync, Handlers.isRetriableError),
+        openSync: retryifySync(fs.openSync, Handlers.isRetriableError),
+        readFileSync: retryifySync(fs.readFileSync, Handlers.isRetriableError),
+        renameSync: retryifySync(fs.renameSync, Handlers.isRetriableError),
+        statSync: retryifySync(fs.statSync, Handlers.isRetriableError),
+        writeSync: retryifySync(fs.writeSync, Handlers.isRetriableError),
+        writeFileSync: retryifySync(fs.writeFileSync, Handlers.isRetriableError)
+    }
+};
+/* EXPORT */
+export default FS;

package/.output/server/node_modules/stubborn-fs/dist/retryify.js

@@ -0,0 +1,46 @@
+/* IMPORT */
+import RetryfyQueue from './retryify_queue.js';
+/* MAIN */
+//FIXME: There are a boatload of anys here, but apparently generics cannot be extended properly, so...
+const retryifyAsync = (fn, isRetriableError) => {
+    return function retrified(timestamp) {
+        return function attempt(...args) {
+            return RetryfyQueue.schedule().then(cleanup => {
+                const onResolve = (result) => {
+                    cleanup();
+                    return result;
+                };
+                const onReject = (error) => {
+                    cleanup();
+                    if (Date.now() >= timestamp)
+                        throw error;
+                    if (isRetriableError(error)) {
+                        const delay = Math.round(100 * Math.random());
+                        const delayPromise = new Promise(resolve => setTimeout(resolve, delay));
+                        return delayPromise.then(() => attempt.apply(undefined, args));
+                    }
+                    throw error;
+                };
+                return fn.apply(undefined, args).then(onResolve, onReject);
+            });
+        };
+    };
+};
+const retryifySync = (fn, isRetriableError) => {
+    return function retrified(timestamp) {
+        return function attempt(...args) {
+            try {
+                return fn.apply(undefined, args);
+            }
+            catch (error) {
+                if (Date.now() > timestamp)
+                    throw error;
+                if (isRetriableError(error))
+                    return attempt.apply(undefined, args);
+                throw error;
+            }
+        };
+    };
+};
+/* EXPORT */
+export { retryifyAsync, retryifySync };

package/.output/server/node_modules/stubborn-fs/dist/retryify_queue.js

@@ -0,0 +1,62 @@
+/* IMPORT */
+import { LIMIT_FILES_DESCRIPTORS } from './constants.js';
+/* MAIN */
+class RetryfyQueue {
+    constructor() {
+        /* VARIABLES */
+        this.interval = 25;
+        this.intervalId = undefined;
+        this.limit = LIMIT_FILES_DESCRIPTORS;
+        this.queueActive = new Set();
+        this.queueWaiting = new Set();
+        /* LIFECYCLE API */
+        this.init = () => {
+            if (this.intervalId)
+                return;
+            this.intervalId = setInterval(this.tick, this.interval);
+        };
+        this.reset = () => {
+            if (!this.intervalId)
+                return;
+            clearInterval(this.intervalId);
+            delete this.intervalId;
+        };
+        /* API */
+        this.add = (fn) => {
+            this.queueWaiting.add(fn);
+            if (this.queueActive.size < (this.limit / 2)) { // Active queue not under preassure, executing immediately
+                this.tick();
+            }
+            else {
+                this.init();
+            }
+        };
+        this.remove = (fn) => {
+            this.queueWaiting.delete(fn);
+            this.queueActive.delete(fn);
+        };
+        this.schedule = () => {
+            return new Promise(resolve => {
+                const cleanup = () => this.remove(resolver);
+                const resolver = () => resolve(cleanup);
+                this.add(resolver);
+            });
+        };
+        this.tick = () => {
+            if (this.queueActive.size >= this.limit)
+                return;
+            if (!this.queueWaiting.size)
+                return this.reset();
+            for (const fn of this.queueWaiting) {
+                if (this.queueActive.size >= this.limit)
+                    break;
+                this.queueWaiting.delete(fn);
+                this.queueActive.add(fn);
+                fn();
+            }
+        };
+    }
+}
+;
+/* EXPORT */
+export default new RetryfyQueue();

package/.output/server/node_modules/stubborn-fs/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "stubborn-fs",
+  "repository": "github:fabiospampinato/stubborn-fs",
+  "description": "Stubborn versions of Node's fs functions that try really hard to do their job.",
+  "version": "1.2.5",
+  "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",
+    "prepublishOnly": "tsex prepare"
+  },
+  "keywords": [
+    "fs",
+    "attempt",
+    "retry",
+    "stubborn",
+    "reliable"
+  ],
+  "devDependencies": {
+    "@types/node": "^18.13.0",
+    "tsex": "^2.1.0",
+    "typescript": "^4.9.5"
+  }
+}