@aeolus-fleet/console 0.29.1 → 0.30.0

package/.next/standalone/node_modules/import-in-the-middle/lib/register.js

@@ -0,0 +1,285 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2.0 License.
+//
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc.
+
+const importHooks = [] // TODO should this be a Set?
+const binders = new WeakMap()
+let legacySetters
+let legacyGetters
+let legacyProxyHandler
+const specifiers = new Map()
+const toHook = []
+
+/**
+ * @param {object} source The module namespace.
+ * @param {string | symbol} name The export name.
+ */
+function readExport (source, name) {
+  if (name === 'module.exports' && !Object.hasOwn(source, name)) {
+    return source.default
+  }
+  return source[name]
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {unknown} value The replacement value.
+ */
+function setExport (target, name, value) {
+  return binders.get(target).write(name, value)
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {PropertyDescriptor} descriptor The replacement descriptor.
+ */
+function defineExport (target, name, descriptor) {
+  if (!('value' in descriptor)) {
+    throw new Error('Getters/setters are not supported for exports property descriptors.')
+  }
+  return setExport(target, name, descriptor.value)
+}
+
+const proxyHandler = { defineProperty: defineExport, set: setExport }
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {unknown} value The replacement value.
+ */
+function setLegacyExport (target, name, value) {
+  const setter = legacySetters.get(target)?.[name]
+  return typeof setter === 'function' ? setter(value) : true
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ */
+function getLegacyExport (target, name) {
+  if (name === Symbol.toStringTag) return 'Module'
+
+  const getter = legacyGetters.get(target)[name]
+  if (typeof getter === 'function') return getter()
+}
+
+/**
+ * @param {object} target The proxy target.
+ * @param {string | symbol} name The export name.
+ * @param {PropertyDescriptor} descriptor The replacement descriptor.
+ */
+function defineLegacyExport (target, name, descriptor) {
+  if (!('value' in descriptor)) {
+    throw new Error('Getters/setters are not supported for exports property descriptors.')
+  }
+  return setLegacyExport(target, name, descriptor.value)
+}
+
+/**
+ * @param {string} name The wrapped module URL.
+ * @param {object} namespace The wrapper's module namespace.
+ * @param {object} set The wrapper's export setters.
+ * @param {object} get The wrapper's export getters.
+ * @param {string} specifier The original import specifier.
+ */
+function registerLegacy (name, namespace, set, get, specifier) {
+  legacySetters ??= new WeakMap()
+  legacyGetters ??= new WeakMap()
+  legacyProxyHandler ??= {
+    defineProperty: defineLegacyExport,
+    get: getLegacyExport,
+    set: setLegacyExport
+  }
+  specifiers.set(name, specifier)
+  legacySetters.set(namespace, set)
+  legacyGetters.set(namespace, get)
+  const proxy = new Proxy(namespace, legacyProxyHandler)
+  importHooks.forEach(hook => hook(name, proxy, specifier))
+  toHook.push([name, proxy, specifier])
+}
+
+/**
+ * @param {string} name The wrapped module URL.
+ * @param {ModuleBinder | object} binder The wrapper's binding state or legacy namespace.
+ * @param {string | object} specifier The original import specifier or legacy setters.
+ * @param {object} [get] The legacy export getters.
+ * @param {string} [legacySpecifier] The legacy original import specifier.
+ */
+function register (name, binder, specifier, get, legacySpecifier) {
+  if (arguments.length === 5) {
+    registerLegacy(name, binder, specifier, get, legacySpecifier)
+    return
+  }
+
+  const { namespace } = binder
+  specifiers.set(name, specifier)
+  binders.set(namespace, binder)
+  const proxy = new Proxy(namespace, proxyHandler)
+  importHooks.forEach(hook => hook(name, proxy, specifier))
+  toHook.push([name, proxy, specifier])
+}
+
+// Delays (ms) for re-reading exports that were still in their temporal dead zone
+// when the wrapper first ran (circular imports). Retried on a microtask first,
+// then at these intervals; unref'd so best-effort retries never hold the process
+// open. Frozen once at module load rather than rebuilt per wrapper.
+const RETRY_DELAYS = [0, 10, 50]
+
+/**
+ * Per-wrapped-module state a generated wrapper builds once to expose its exports
+ * through iitm's proxy. Each wrapper supplies one indexed writer for all local
+ * bindings; the constructor seeds them from the real module, and `flush`
+ * resolves any export that was undefined (circular import) once it becomes available.
+ *
+ * This is the boilerplate the wrapper used to inline in full per module. Hoisting
+ * it here compiles the retry and proxy bookkeeping once instead of once per
+ * wrapped module.
+ */
+class ModuleBinder {
+  // Mimics a Module namespace object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+  namespace = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } })
+  #set = Object.create(null)
+  #write
+  #overridden
+  #pending
+
+  /**
+   * @param {object} source The wrapped module namespace.
+   * @param {string[]} [keys] Export names in wrapper-binding order.
+   * @param {(index: number, value: unknown) => void} [write] Assigns a wrapper binding by index.
+   * @param {object[]} [sources] Alternate namespaces for star-collision bindings.
+   */
+  constructor (source, keys, write, sources) {
+    this.#write = write
+    if (keys !== undefined) {
+      for (let index = 0; index < keys.length; index++) {
+        this.#bind(keys[index], index, sources?.[index] ?? source)
+      }
+    }
+  }
+
+  /**
+   * Seeds `key` from `source` and installs its proxy accessors. A value that is
+   * undefined or throws `ReferenceError` (temporal dead zone during a circular
+   * import) is deferred to `flush`; any other throw propagates.
+   *
+   * @param {string} key The export name.
+   * @param {number} index The wrapper binding index.
+   * @param {object} source The binding's source namespace.
+   * @returns {void}
+   */
+  #bind (key, index, source) {
+    let value
+    try {
+      value = readExport(source, key)
+      this.#write(index, value)
+      this.namespace[key] = value
+    } catch (error) {
+      if (!(error instanceof ReferenceError)) throw error
+    }
+    if (value === undefined) {
+      (this.#pending ??= []).push(this.#makeUpdater(key, index, source))
+    }
+    this.#set[key] = index
+  }
+
+  /**
+   * @param {string | symbol} key The export name.
+   * @param {unknown} value The replacement value.
+   * @returns {boolean}
+   */
+  write (key, value) {
+    const index = this.#set[key]
+    if (index !== undefined) {
+      this.#write(index, value)
+      if (this.#pending !== undefined) {
+        this.#overridden ??= Object.create(null)
+        this.#overridden[key] = true
+      }
+      this.namespace[key] = value
+    }
+    return true
+  }
+
+  /**
+   * @param {string} key The export name to update.
+   * @param {number} index The wrapper binding index.
+   * @param {object} source The real module namespace.
+   * @returns {() => boolean} Updater returning whether the value is now settled.
+   */
+  #makeUpdater (key, index, source) {
+    return () => {
+      if (this.#overridden?.[key] === true) return true
+      try {
+        const value = readExport(source, key)
+        if (value !== undefined) {
+          this.#write(index, value)
+          this.namespace[key] = value
+          return true
+        }
+        return false
+      } catch (error) {
+        if (error instanceof ReferenceError) return false
+        // Only reached if a getter starts throwing a non-ReferenceError after the
+        // initial bind read already succeeded or deferred; surfaces in flush's
+        // microtask. Kept as-is from the inline wrapper.
+        /* c8 ignore next */
+        throw error
+      }
+    }
+  }
+
+  #flushOnce () {
+    const pending = this.#pending
+    if (pending === undefined) return
+
+    let next
+    for (const updater of pending) {
+      // If it still throws ReferenceError, keep it for the (single) next attempt.
+      if (updater() !== true) (next ??= []).push(updater)
+    }
+    this.#pending = next
+  }
+
+  /**
+   * Resolves exports deferred by `bind` (undefined or TDZ at wrapper-eval time).
+   * Retries on a microtask, then at `RETRY_DELAYS`, giving up afterwards to avoid
+   * unbounded retries. A no-op when nothing was deferred.
+   *
+   * @returns {void}
+   */
+  flush () {
+    if (this.#pending === undefined) return
+    queueMicrotask(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(0)
+    })
+  }
+
+  /**
+   * @param {number} attempt Index into `RETRY_DELAYS` for the next retry.
+   * @returns {void}
+   */
+  #scheduleRetry (attempt) {
+    if (this.#pending === undefined) return
+    if (attempt >= RETRY_DELAYS.length) {
+      // Give up: leave exports as-is to avoid unbounded retries.
+      this.#pending = undefined
+      return
+    }
+    const timer = setTimeout(() => {
+      this.#flushOnce()
+      this.#scheduleRetry(attempt + 1)
+    }, RETRY_DELAYS[attempt])
+    // Don't keep the process alive just for best-effort retries.
+    if (timer && typeof timer.unref === 'function') timer.unref()
+  }
+}
+
+exports.register = register
+exports.ModuleBinder = ModuleBinder
+exports.importHooks = importHooks
+exports.specifiers = specifiers
+exports.toHook = toHook

package/.next/standalone/node_modules/import-in-the-middle/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "import-in-the-middle",
+  "version": "3.5.2",
+  "description": "Intercept imports in Node.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "c8 --reporter lcov --check-coverage --lines 45 imhotap --files test/{hook,low-level,other,get-esm-exports,register}/*",
+    "test:e2e": "node test/check-exports/test.mjs && node test/integration-tests/turbopack-dev.mjs && node test/integration-tests/turbopack-build-start.mjs",
+    "test:ts": "c8 --reporter lcov imhotap --files test/typescript/*.test.mts",
+    "coverage": "c8 --reporter html imhotap --files test/{hook,low-level,other,get-esm-exports,register}/* && echo \"\nNow open coverage/index.html\n\"",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/nodejs/import-in-the-middle.git"
+  },
+  "keywords": [
+    "import",
+    "ritm",
+    "iitm",
+    "loader",
+    "hook",
+    "hooks"
+  ],
+  "author": "Bryan English <bryan.english@datadoghq.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/nodejs/import-in-the-middle/issues"
+  },
+  "homepage": "https://github.com/nodejs/import-in-the-middle#readme",
+  "imhotap": {
+    "runner": "node",
+    "test-env": "NODE_OPTIONS=--no-warnings --require ./test/version-check.js --experimental-loader ./test/generic-loader.mjs"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/eslint-parser": "^7.28.5",
+    "@babel/plugin-syntax-import-assertions": "^7.27.1",
+    "@node-rs/crc32": "^1.10.6",
+    "@react-email/components": "^0.0.19",
+    "@types/node": "^18.0.6",
+    "c8": "^7.14.0",
+    "date-fns": "^3.6.0",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.6.0",
+    "got": "^14.6.6",
+    "imhotap": "^2.2.0",
+    "openai": "4.47.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5",
+    "vue": "^3.5.26"
+  },
+  "dependencies": {
+    "cjs-module-lexer": "^2.2.0",
+    "es-module-lexer": "^3.0.2",
+    "module-details-from-path": "^1.0.4"
+  }
+}

package/.next/standalone/node_modules/module-details-from-path/index.js

@@ -0,0 +1,41 @@
+'use strict'
+
+var sep = require('path').sep
+
+module.exports = function (file) {
+  var segments = file.split(sep)
+  var index = segments.lastIndexOf('node_modules')
+
+  if (index === -1) return
+  if (!segments[index + 1]) return
+
+  var scoped = segments[index + 1][0] === '@'
+  var name = scoped ? segments[index + 1] + '/' + segments[index + 2] : segments[index + 1]
+  var offset = scoped ? 3 : 2
+
+  var basedir = ''
+  var lastBaseDirSegmentIndex = index + offset - 1
+  for (var i = 0; i <= lastBaseDirSegmentIndex; i++) {
+    if (i === lastBaseDirSegmentIndex) {
+      basedir += segments[i]
+    } else {
+      basedir += segments[i] + sep
+    }
+  }
+
+  var path = ''
+  var lastSegmentIndex = segments.length - 1
+  for (var i2 = index + offset; i2 <= lastSegmentIndex; i2++) {
+    if (i2 === lastSegmentIndex) {
+      path += segments[i2]
+    } else {
+      path += segments[i2] + sep
+    }
+  }
+
+  return {
+    name: name,
+    basedir: basedir,
+    path: path
+  }
+}

package/.next/standalone/node_modules/module-details-from-path/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "module-details-from-path",
+  "version": "1.0.4",
+  "description": "Resolve npm package details, like name and base path, given an absolute path to a file inside a package",
+  "main": "index.js",
+  "files": [],
+  "dependencies": {},
+  "devDependencies": {
+    "bench-node": "^0.5.4",
+    "standard": "^15.0.1",
+    "tape": "^4.6.0"
+  },
+  "scripts": {
+    "bench": "node --allow-natives-syntax bench.js",
+    "lint": "standard",
+    "test": "standard && node test.js",
+    "test:ci": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/watson/module-details-from-path.git"
+  },
+  "keywords": [
+    "node",
+    "nodejs",
+    "npm",
+    "module",
+    "package",
+    "extract",
+    "parse",
+    "name",
+    "basedir",
+    "directory",
+    "path",
+    "relative"
+  ],
+  "author": "Thomas Watson <w@tson.dk> (https://wa.tson.dk/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/watson/module-details-from-path/issues"
+  },
+  "homepage": "https://github.com/watson/module-details-from-path#readme",
+  "coordinates": [
+    55.666507,
+    12.5798711
+  ]
+}

package/.next/standalone/node_modules/ms/index.js

@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function (val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}

package/.next/standalone/node_modules/ms/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ms",
+  "version": "2.1.3",
+  "description": "Tiny millisecond conversion utility",
+  "repository": "vercel/ms",
+  "main": "./index",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "precommit": "lint-staged",
+    "lint": "eslint lib/* bin/*",
+    "test": "mocha tests.js"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "env": {
+      "node": true,
+      "es6": true
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "npm run lint",
+      "prettier --single-quote --write",
+      "git add"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "4.18.2",
+    "expect.js": "0.3.1",
+    "husky": "0.14.3",
+    "lint-staged": "5.0.0",
+    "mocha": "4.0.1",
+    "prettier": "2.0.5"
+  }
+}