nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/_deps/rc9.mjs

@@ -1,219 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { homedir } from 'node:os';
-import destr from 'destr';
-import 'defu';
-
-function isBuffer (obj) {
-  return obj &&
-    obj.constructor &&
-    (typeof obj.constructor.isBuffer === 'function') &&
-    obj.constructor.isBuffer(obj)
-}
-
-function keyIdentity (key) {
-  return key
-}
-
-function flatten (target, opts) {
-  opts = opts || {};
-
-  const delimiter = opts.delimiter || '.';
-  const maxDepth = opts.maxDepth;
-  const transformKey = opts.transformKey || keyIdentity;
-  const output = {};
-
-  function step (object, prev, currentDepth) {
-    currentDepth = currentDepth || 1;
-    Object.keys(object).forEach(function (key) {
-      const value = object[key];
-      const isarray = opts.safe && Array.isArray(value);
-      const type = Object.prototype.toString.call(value);
-      const isbuffer = isBuffer(value);
-      const isobject = (
-        type === '[object Object]' ||
-        type === '[object Array]'
-      );
-
-      const newKey = prev
-        ? prev + delimiter + transformKey(key)
-        : transformKey(key);
-
-      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
-        (!opts.maxDepth || currentDepth < maxDepth)) {
-        return step(value, newKey, currentDepth + 1)
-      }
-
-      output[newKey] = value;
-    });
-  }
-
-  step(target);
-
-  return output
-}
-
-function unflatten (target, opts) {
-  opts = opts || {};
-
-  const delimiter = opts.delimiter || '.';
-  const overwrite = opts.overwrite || false;
-  const transformKey = opts.transformKey || keyIdentity;
-  const result = {};
-
-  const isbuffer = isBuffer(target);
-  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
-    return target
-  }
-
-  // safely ensure that the key is
-  // an integer.
-  function getkey (key) {
-    const parsedKey = Number(key);
-
-    return (
-      isNaN(parsedKey) ||
-      key.indexOf('.') !== -1 ||
-      opts.object
-    )
-      ? key
-      : parsedKey
-  }
-
-  function addKeys (keyPrefix, recipient, target) {
-    return Object.keys(target).reduce(function (result, key) {
-      result[keyPrefix + delimiter + key] = target[key];
-
-      return result
-    }, recipient)
-  }
-
-  function isEmpty (val) {
-    const type = Object.prototype.toString.call(val);
-    const isArray = type === '[object Array]';
-    const isObject = type === '[object Object]';
-
-    if (!val) {
-      return true
-    } else if (isArray) {
-      return !val.length
-    } else if (isObject) {
-      return !Object.keys(val).length
-    }
-  }
-
-  target = Object.keys(target).reduce(function (result, key) {
-    const type = Object.prototype.toString.call(target[key]);
-    const isObject = (type === '[object Object]' || type === '[object Array]');
-    if (!isObject || isEmpty(target[key])) {
-      result[key] = target[key];
-      return result
-    } else {
-      return addKeys(
-        key,
-        result,
-        flatten(target[key], opts)
-      )
-    }
-  }, {});
-
-  Object.keys(target).forEach(function (key) {
-    const split = key.split(delimiter).map(transformKey);
-    let key1 = getkey(split.shift());
-    let key2 = getkey(split[0]);
-    let recipient = result;
-
-    while (key2 !== undefined) {
-      if (key1 === '__proto__') {
-        return
-      }
-
-      const type = Object.prototype.toString.call(recipient[key1]);
-      const isobject = (
-        type === '[object Object]' ||
-        type === '[object Array]'
-      );
-
-      // do not write over falsey, non-undefined values if overwrite is false
-      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
-        return
-      }
-
-      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
-        recipient[key1] = (
-          typeof key2 === 'number' &&
-          !opts.object
-            ? []
-            : {}
-        );
-      }
-
-      recipient = recipient[key1];
-      if (split.length > 0) {
-        key1 = getkey(split.shift());
-        key2 = getkey(split[0]);
-      }
-    }
-
-    // unflatten again for 'messy objects'
-    recipient[key1] = unflatten(target[key], opts);
-  });
-
-  return result
-}
-
-const RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
-const RE_LINES = /\n|\r|\r\n/;
-const defaults = {
-  name: ".conf",
-  dir: process.cwd(),
-  flat: false
-};
-function withDefaults(options) {
-  if (typeof options === "string") {
-    options = { name: options };
-  }
-  return { ...defaults, ...options };
-}
-function parse(contents, options = {}) {
-  const config = {};
-  const lines = contents.split(RE_LINES);
-  for (const line of lines) {
-    const match = line.match(RE_KEY_VAL);
-    if (!match) {
-      continue;
-    }
-    const key = match[1];
-    if (!key || key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = destr(
-      (match[2] || "").trim()
-      /* val */
-    );
-    if (key.endsWith("[]")) {
-      const nkey = key.slice(0, Math.max(0, key.length - 2));
-      config[nkey] = (config[nkey] || []).concat(value);
-      continue;
-    }
-    config[key] = value;
-  }
-  return options.flat ? config : unflatten(config, { overwrite: true });
-}
-function parseFile(path, options) {
-  if (!existsSync(path)) {
-    return {};
-  }
-  return parse(readFileSync(path, "utf8"), options);
-}
-function read(options) {
-  options = withDefaults(options);
-  return parseFile(resolve(options.dir, options.name), options);
-}
-function readUser(options) {
-  options = withDefaults(options);
-  options.dir = process.env.XDG_CONFIG_HOME || homedir();
-  return read(options);
-}
-
-export { readUser as a, read as r };

package/dist/_chunks/_deps/readdirp.mjs

@@ -1,245 +0,0 @@
-import { lstat, stat, readdir, realpath } from 'node:fs/promises';
-import { Readable } from 'node:stream';
-import { resolve, join, relative, sep } from 'node:path';
-
-const EntryTypes = {
-    FILE_TYPE: 'files',
-    DIR_TYPE: 'directories',
-    FILE_DIR_TYPE: 'files_directories',
-    EVERYTHING_TYPE: 'all',
-};
-const defaultOptions = {
-    root: '.',
-    fileFilter: (_entryInfo) => true,
-    directoryFilter: (_entryInfo) => true,
-    type: EntryTypes.FILE_TYPE,
-    lstat: false,
-    depth: 2147483648,
-    alwaysStat: false,
-    highWaterMark: 4096,
-};
-Object.freeze(defaultOptions);
-const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
-const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
-const ALL_TYPES = [
-    EntryTypes.DIR_TYPE,
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-    EntryTypes.FILE_TYPE,
-];
-const DIR_TYPES = new Set([
-    EntryTypes.DIR_TYPE,
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-]);
-const FILE_TYPES = new Set([
-    EntryTypes.EVERYTHING_TYPE,
-    EntryTypes.FILE_DIR_TYPE,
-    EntryTypes.FILE_TYPE,
-]);
-const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
-const wantBigintFsStats = process.platform === 'win32';
-const emptyFn = (_entryInfo) => true;
-const normalizeFilter = (filter) => {
-    if (filter === undefined)
-        return emptyFn;
-    if (typeof filter === 'function')
-        return filter;
-    if (typeof filter === 'string') {
-        const fl = filter.trim();
-        return (entry) => entry.basename === fl;
-    }
-    if (Array.isArray(filter)) {
-        const trItems = filter.map((item) => item.trim());
-        return (entry) => trItems.some((f) => entry.basename === f);
-    }
-    return emptyFn;
-};
-/** Readable readdir stream, emitting new files as they're being listed. */
-class ReaddirpStream extends Readable {
-    constructor(options = {}) {
-        super({
-            objectMode: true,
-            autoDestroy: true,
-            highWaterMark: options.highWaterMark,
-        });
-        const opts = { ...defaultOptions, ...options };
-        const { root, type } = opts;
-        this._fileFilter = normalizeFilter(opts.fileFilter);
-        this._directoryFilter = normalizeFilter(opts.directoryFilter);
-        const statMethod = opts.lstat ? lstat : stat;
-        // Use bigint stats if it's windows and stat() supports options (node 10+).
-        if (wantBigintFsStats) {
-            this._stat = (path) => statMethod(path, { bigint: true });
-        }
-        else {
-            this._stat = statMethod;
-        }
-        this._maxDepth = opts.depth ?? defaultOptions.depth;
-        this._wantsDir = type ? DIR_TYPES.has(type) : false;
-        this._wantsFile = type ? FILE_TYPES.has(type) : false;
-        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-        this._root = resolve(root);
-        this._isDirent = !opts.alwaysStat;
-        this._statsProp = this._isDirent ? 'dirent' : 'stats';
-        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
-        // Launch stream with one parent, the root dir.
-        this.parents = [this._exploreDir(root, 1)];
-        this.reading = false;
-        this.parent = undefined;
-    }
-    async _read(batch) {
-        if (this.reading)
-            return;
-        this.reading = true;
-        try {
-            while (!this.destroyed && batch > 0) {
-                const par = this.parent;
-                const fil = par && par.files;
-                if (fil && fil.length > 0) {
-                    const { path, depth } = par;
-                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
-                    const awaited = await Promise.all(slice);
-                    for (const entry of awaited) {
-                        if (!entry)
-                            continue;
-                        if (this.destroyed)
-                            return;
-                        const entryType = await this._getEntryType(entry);
-                        if (entryType === 'directory' && this._directoryFilter(entry)) {
-                            if (depth <= this._maxDepth) {
-                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-                            }
-                            if (this._wantsDir) {
-                                this.push(entry);
-                                batch--;
-                            }
-                        }
-                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
-                            this._fileFilter(entry)) {
-                            if (this._wantsFile) {
-                                this.push(entry);
-                                batch--;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const parent = this.parents.pop();
-                    if (!parent) {
-                        this.push(null);
-                        break;
-                    }
-                    this.parent = await parent;
-                    if (this.destroyed)
-                        return;
-                }
-            }
-        }
-        catch (error) {
-            this.destroy(error);
-        }
-        finally {
-            this.reading = false;
-        }
-    }
-    async _exploreDir(path, depth) {
-        let files;
-        try {
-            files = await readdir(path, this._rdOptions);
-        }
-        catch (error) {
-            this._onError(error);
-        }
-        return { files, depth, path };
-    }
-    async _formatEntry(dirent, path) {
-        let entry;
-        const basename = this._isDirent ? dirent.name : dirent;
-        try {
-            const fullPath = resolve(join(path, basename));
-            entry = { path: relative(this._root, fullPath), fullPath, basename };
-            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-        }
-        catch (err) {
-            this._onError(err);
-            return;
-        }
-        return entry;
-    }
-    _onError(err) {
-        if (isNormalFlowError(err) && !this.destroyed) {
-            this.emit('warn', err);
-        }
-        else {
-            this.destroy(err);
-        }
-    }
-    async _getEntryType(entry) {
-        // entry may be undefined, because a warning or an error were emitted
-        // and the statsProp is undefined
-        if (!entry && this._statsProp in entry) {
-            return '';
-        }
-        const stats = entry[this._statsProp];
-        if (stats.isFile())
-            return 'file';
-        if (stats.isDirectory())
-            return 'directory';
-        if (stats && stats.isSymbolicLink()) {
-            const full = entry.fullPath;
-            try {
-                const entryRealPath = await realpath(full);
-                const entryRealPathStats = await lstat(entryRealPath);
-                if (entryRealPathStats.isFile()) {
-                    return 'file';
-                }
-                if (entryRealPathStats.isDirectory()) {
-                    const len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
-                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-                        // @ts-ignore
-                        recursiveError.code = RECURSIVE_ERROR_CODE;
-                        return this._onError(recursiveError);
-                    }
-                    return 'directory';
-                }
-            }
-            catch (error) {
-                this._onError(error);
-                return '';
-            }
-        }
-    }
-    _includeAsFile(entry) {
-        const stats = entry && entry[this._statsProp];
-        return stats && this._wantsEverything && !stats.isDirectory();
-    }
-}
-/**
- * Streaming version: Reads all files and directories in given root recursively.
- * Consumes ~constant small amount of RAM.
- * @param root Root directory
- * @param options Options to specify root (start directory), filters and recursion depth
- */
-function readdirp(root, options = {}) {
-    // @ts-ignore
-    let type = options.entryType || options.type;
-    if (type === 'both')
-        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
-    if (type)
-        options.type = type;
-    if (!root) {
-        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
-    }
-    else if (typeof root !== 'string') {
-        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
-    }
-    else if (type && !ALL_TYPES.includes(type)) {
-        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
-    }
-    options.root = root;
-    return new ReaddirpStream(options);
-}
-
-export { readdirp as r };