@highstate/designer 0.4.5 → 0.4.6

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

@@ -1,52 +0,0 @@
-{
-  "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

@@ -1,141 +0,0 @@
-/*
-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

@@ -1,39 +0,0 @@
-{
-  "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

@@ -1,16 +0,0 @@
-'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

@@ -1,40 +0,0 @@
-{
-  "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

@@ -1,19 +0,0 @@
-/* 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

@@ -1,8 +0,0 @@
-/* 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

@@ -1,36 +0,0 @@
-/* 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

@@ -1,53 +0,0 @@
-/* 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

@@ -1,46 +0,0 @@
-/* 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

@@ -1,62 +0,0 @@
-/* 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

@@ -1,28 +0,0 @@
-{
-  "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"
-  }
-}