Ignore:
Timestamp:
01/21/25 03:08:24 (3 days ago)
Author:
stefan toskovski <stefantoska84@…>
Branches:
main
Parents:
0c6b92a
Message:

F4 Finalna Verzija

Location:
imaps-frontend/node_modules/readdirp
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • imaps-frontend/node_modules/readdirp/README.md

    r0c6b92a r79a0317  
    11# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
    22
    3 Recursive version of [fs.readdir](https://nodejs.org/api/fs.html#fs_fs_readdir_path_options_callback). Exposes a **stream API** and a **promise API**.
    4 
    5 Supports both ESM and common.js.
     3Recursive version of fs.readdir. Exposes a **stream API** (with small RAM & CPU footprint) and a **promise API**.
    64
    75```sh
    86npm install readdirp
     7jsr add jsr:@paulmillr/readdirp
    98```
    109

  • imaps-frontend/node_modules/readdirp/esm/index.d.ts

    r0c6b92a r79a0317  
    1 import type { Stats, Dirent } from 'fs';
    2 import { Readable } from 'stream';
     1/**
     2 * Recursive version of readdir. Exposes a streaming API and promise API.
     3 * Streaming API allows to use a small amount of RAM.
     4 *
     5 * @module
     6 * @example
     7```js
     8import readdirp from 'readdirp';
     9for await (const entry of readdirp('.')) {
     10  const {path} = entry;
     11  console.log(`${JSON.stringify({path})}`);
     12}
     13```
     14 */
     15/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */
     16import type { Stats, Dirent } from 'node:fs';
     17import { Readable } from 'node:stream';
     18/** Path in file system. */
    319export type Path = string;
     20/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
    421export interface EntryInfo {
    522    path: string;
    … …  
    926    basename: string;
    1027}
     28/** Path or dir entries (files) */
    1129export type PathOrDirent = Dirent | Path;
    12 export type Tester = (path: EntryInfo) => boolean;
     30/** Filterer for files */
     31export type Tester = (entryInfo: EntryInfo) => boolean;
    1332export type Predicate = string[] | string | Tester;
    14 declare function defaultOptions(): {
     33export declare const EntryTypes: {
     34    readonly FILE_TYPE: "files";
     35    readonly DIR_TYPE: "directories";
     36    readonly FILE_DIR_TYPE: "files_directories";
     37    readonly EVERYTHING_TYPE: "all";
     38};
     39export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
     40/**
     41 * Options for readdirp.
     42 * * type: files, directories, or both
     43 * * lstat: whether to use symlink-friendly stat
     44 * * depth: max depth
     45 * * alwaysStat: whether to use stat (more resources) or dirent
     46 * * highWaterMark: streaming param, specifies max amount of resources per entry
     47 */
     48export type ReaddirpOptions = {
    1549    root: string;
    16     fileFilter: (_path: EntryInfo) => boolean;
    17     directoryFilter: (_path: EntryInfo) => boolean;
    18     type: string;
    19     lstat: boolean;
    20     depth: number;
    21     alwaysStat: boolean;
    22     highWaterMark: number;
     50    fileFilter?: Predicate;
     51    directoryFilter?: Predicate;
     52    type?: EntryType;
     53    lstat?: boolean;
     54    depth?: number;
     55    alwaysStat?: boolean;
     56    highWaterMark?: number;
    2357};
    24 export type ReaddirpOptions = ReturnType<typeof defaultOptions>;
     58/** Directory entry. Contains path, depth count, and files. */
    2559export interface DirEntry {
    2660    files: PathOrDirent[];
    … …  
    2862    path: Path;
    2963}
     64/** Readable readdir stream, emitting new files as they're being listed. */
    3065export declare class ReaddirpStream extends Readable {
    3166    parents: any[];
    … …  
    5590    _formatEntry(dirent: PathOrDirent, path: Path): Promise<EntryInfo | undefined>;
    5691    _onError(err: Error): void;
    57     _getEntryType(entry: EntryInfo): Promise<void | "" | "file" | "directory">;
     92    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
    5893    _includeAsFile(entry: EntryInfo): boolean | undefined;
    5994}
    6095/**
    61  * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
     96 * Streaming version: Reads all files and directories in given root recursively.
     97 * Consumes ~constant small amount of RAM.
    6298 * @param root Root directory
    6399 * @param options Options to specify root (start directory), filters and recursion depth
    64100 */
    65 export declare const readdirp: (root: Path, options?: Partial<ReaddirpOptions>) => ReaddirpStream;
    66 export declare const readdirpPromise: (root: Path, options?: Partial<ReaddirpOptions>) => Promise<string[]>;
     101export declare function readdirp(root: Path, options?: Partial<ReaddirpOptions>): ReaddirpStream;
     102/**
     103 * Promise version: Reads all files and directories in given root recursively.
     104 * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
     105 * @returns array of paths and their entry infos
     106 */
     107export declare function readdirpPromise(root: Path, options?: Partial<ReaddirpOptions>): Promise<EntryInfo[]>;
    67108export default readdirp;

  • imaps-frontend/node_modules/readdirp/esm/index.js

    r0c6b92a r79a0317  
    1 import { stat, lstat, readdir, realpath } from 'fs/promises';
    2 import { Readable } from 'stream';
    3 import { resolve as pathResolve, relative as pathRelative, join as pathJoin, sep as pathSep, } from 'path';
    4 function defaultOptions() {
    5     return {
    6         root: '.',
    7         fileFilter: (_path) => true,
    8         directoryFilter: (_path) => true,
    9         type: FILE_TYPE,
    10         lstat: false,
    11         depth: 2147483648,
    12         alwaysStat: false,
    13         highWaterMark: 4096,
    14     };
    15 }
     1import { stat, lstat, readdir, realpath } from 'node:fs/promises';
     2import { Readable } from 'node:stream';
     3import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from 'node:path';
     4export const EntryTypes = {
     5    FILE_TYPE: 'files',
     6    DIR_TYPE: 'directories',
     7    FILE_DIR_TYPE: 'files_directories',
     8    EVERYTHING_TYPE: 'all',
     9};
     10const defaultOptions = {
     11    root: '.',
     12    fileFilter: (_entryInfo) => true,
     13    directoryFilter: (_entryInfo) => true,
     14    type: EntryTypes.FILE_TYPE,
     15    lstat: false,
     16    depth: 2147483648,
     17    alwaysStat: false,
     18    highWaterMark: 4096,
     19};
     20Object.freeze(defaultOptions);
    1621const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
    1722const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
    18 const FILE_TYPE = 'files';
    19 const DIR_TYPE = 'directories';
    20 const FILE_DIR_TYPE = 'files_directories';
    21 const EVERYTHING_TYPE = 'all';
    22 const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
    23 const DIR_TYPES = new Set([DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
    24 const FILE_TYPES = new Set([FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
     23const ALL_TYPES = [
     24    EntryTypes.DIR_TYPE,
     25    EntryTypes.EVERYTHING_TYPE,
     26    EntryTypes.FILE_DIR_TYPE,
     27    EntryTypes.FILE_TYPE,
     28];
     29const DIR_TYPES = new Set([
     30    EntryTypes.DIR_TYPE,
     31    EntryTypes.EVERYTHING_TYPE,
     32    EntryTypes.FILE_DIR_TYPE,
     33]);
     34const FILE_TYPES = new Set([
     35    EntryTypes.EVERYTHING_TYPE,
     36    EntryTypes.FILE_DIR_TYPE,
     37    EntryTypes.FILE_TYPE,
     38]);
    2539const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
    2640const wantBigintFsStats = process.platform === 'win32';
    27 const emptyFn = (_path) => true;
     41const emptyFn = (_entryInfo) => true;
    2842const normalizeFilter = (filter) => {
    2943    if (filter === undefined)
    … …  
    4155    return emptyFn;
    4256};
     57/** Readable readdir stream, emitting new files as they're being listed. */
    4358export class ReaddirpStream extends Readable {
    4459    constructor(options = {}) {
    … …  
    4863            highWaterMark: options.highWaterMark,
    4964        });
    50         const opts = { ...defaultOptions(), ...options };
     65        const opts = { ...defaultOptions, ...options };
    5166        const { root, type } = opts;
    5267        this._fileFilter = normalizeFilter(opts.fileFilter);
    … …  
    6075            this._stat = statMethod;
    6176        }
    62         this._maxDepth = opts.depth;
    63         this._wantsDir = DIR_TYPES.has(type);
    64         this._wantsFile = FILE_TYPES.has(type);
    65         this._wantsEverything = type === EVERYTHING_TYPE;
    66         this._root = pathResolve(root);
     77        this._maxDepth = opts.depth ?? defaultOptions.depth;
     78        this._wantsDir = type ? DIR_TYPES.has(type) : false;
     79        this._wantsFile = type ? FILE_TYPES.has(type) : false;
     80        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
     81        this._root = presolve(root);
    6782        this._isDirent = !opts.alwaysStat;
    6883        this._statsProp = this._isDirent ? 'dirent' : 'stats';
    … …  
    144159        const basename = this._isDirent ? dirent.name : dirent;
    145160        try {
    146             const fullPath = pathResolve(pathJoin(path, basename));
    147             entry = { path: pathRelative(this._root, fullPath), fullPath, basename };
     161            const fullPath = presolve(pjoin(path, basename));
     162            entry = { path: prelative(this._root, fullPath), fullPath, basename };
    148163            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
    149164        }
    … …  
    183198                if (entryRealPathStats.isDirectory()) {
    184199                    const len = entryRealPath.length;
    185                     if (full.startsWith(entryRealPath) && full.substr(len, 1) === pathSep) {
     200                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
    186201                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
    187202                        // @ts-ignore
    … …  
    204219}
    205220/**
    206  * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
     221 * Streaming version: Reads all files and directories in given root recursively.
     222 * Consumes ~constant small amount of RAM.
    207223 * @param root Root directory
    208224 * @param options Options to specify root (start directory), filters and recursion depth
    209225 */
    210 export const readdirp = (root, options = {}) => {
     226export function readdirp(root, options = {}) {
    211227    // @ts-ignore
    212228    let type = options.entryType || options.type;
    213229    if (type === 'both')
    214         type = FILE_DIR_TYPE; // backwards-compatibility
     230        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
    215231    if (type)
    216232        options.type = type;
    … …  
    226242    options.root = root;
    227243    return new ReaddirpStream(options);
    228 };
    229 export const readdirpPromise = (root, options = {}) => {
     244}
     245/**
     246 * Promise version: Reads all files and directories in given root recursively.
     247 * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
     248 * @returns array of paths and their entry infos
     249 */
     250export function readdirpPromise(root, options = {}) {
    230251    return new Promise((resolve, reject) => {
    231252        const files = [];
    … …  
    235256            .on('error', (error) => reject(error));
    236257    });
    237 };
     258}
    238259export default readdirp;

  • imaps-frontend/node_modules/readdirp/index.d.ts

    r0c6b92a r79a0317  
    1 import type { Stats, Dirent } from 'fs';
    2 import { Readable } from 'stream';
     1/**
     2 * Recursive version of readdir. Exposes a streaming API and promise API.
     3 * Streaming API allows to use a small amount of RAM.
     4 *
     5 * @module
     6 * @example
     7```js
     8import readdirp from 'readdirp';
     9for await (const entry of readdirp('.')) {
     10  const {path} = entry;
     11  console.log(`${JSON.stringify({path})}`);
     12}
     13```
     14 */
     15/*! readdirp - MIT License (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com) */
     16import type { Stats, Dirent } from 'node:fs';
     17import { Readable } from 'node:stream';
     18/** Path in file system. */
    319export type Path = string;
     20/** Emitted entry. Contains relative & absolute path, basename, and either stats or dirent. */
    421export interface EntryInfo {
    522    path: string;
    … …  
    926    basename: string;
    1027}
     28/** Path or dir entries (files) */
    1129export type PathOrDirent = Dirent | Path;
    12 export type Tester = (path: EntryInfo) => boolean;
     30/** Filterer for files */
     31export type Tester = (entryInfo: EntryInfo) => boolean;
    1332export type Predicate = string[] | string | Tester;
    14 declare function defaultOptions(): {
     33export declare const EntryTypes: {
     34    readonly FILE_TYPE: "files";
     35    readonly DIR_TYPE: "directories";
     36    readonly FILE_DIR_TYPE: "files_directories";
     37    readonly EVERYTHING_TYPE: "all";
     38};
     39export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
     40/**
     41 * Options for readdirp.
     42 * * type: files, directories, or both
     43 * * lstat: whether to use symlink-friendly stat
     44 * * depth: max depth
     45 * * alwaysStat: whether to use stat (more resources) or dirent
     46 * * highWaterMark: streaming param, specifies max amount of resources per entry
     47 */
     48export type ReaddirpOptions = {
    1549    root: string;
    16     fileFilter: (_path: EntryInfo) => boolean;
    17     directoryFilter: (_path: EntryInfo) => boolean;
    18     type: string;
    19     lstat: boolean;
    20     depth: number;
    21     alwaysStat: boolean;
    22     highWaterMark: number;
     50    fileFilter?: Predicate;
     51    directoryFilter?: Predicate;
     52    type?: EntryType;
     53    lstat?: boolean;
     54    depth?: number;
     55    alwaysStat?: boolean;
     56    highWaterMark?: number;
    2357};
    24 export type ReaddirpOptions = ReturnType<typeof defaultOptions>;
     58/** Directory entry. Contains path, depth count, and files. */
    2559export interface DirEntry {
    2660    files: PathOrDirent[];
    … …  
    2862    path: Path;
    2963}
     64/** Readable readdir stream, emitting new files as they're being listed. */
    3065export declare class ReaddirpStream extends Readable {
    3166    parents: any[];
    … …  
    5590    _formatEntry(dirent: PathOrDirent, path: Path): Promise<EntryInfo | undefined>;
    5691    _onError(err: Error): void;
    57     _getEntryType(entry: EntryInfo): Promise<void | "" | "file" | "directory">;
     92    _getEntryType(entry: EntryInfo): Promise<void | '' | 'file' | 'directory'>;
    5893    _includeAsFile(entry: EntryInfo): boolean | undefined;
    5994}
    6095/**
    61  * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
     96 * Streaming version: Reads all files and directories in given root recursively.
     97 * Consumes ~constant small amount of RAM.
    6298 * @param root Root directory
    6399 * @param options Options to specify root (start directory), filters and recursion depth
    64100 */
    65 export declare const readdirp: (root: Path, options?: Partial<ReaddirpOptions>) => ReaddirpStream;
    66 export declare const readdirpPromise: (root: Path, options?: Partial<ReaddirpOptions>) => Promise<string[]>;
     101export declare function readdirp(root: Path, options?: Partial<ReaddirpOptions>): ReaddirpStream;
     102/**
     103 * Promise version: Reads all files and directories in given root recursively.
     104 * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
     105 * @returns array of paths and their entry infos
     106 */
     107export declare function readdirpPromise(root: Path, options?: Partial<ReaddirpOptions>): Promise<EntryInfo[]>;
    67108export default readdirp;

  • imaps-frontend/node_modules/readdirp/index.js

    r0c6b92a r79a0317  
    11"use strict";
    22Object.defineProperty(exports, "__esModule", { value: true });
    3 exports.readdirpPromise = exports.readdirp = exports.ReaddirpStream = void 0;
    4 const promises_1 = require("fs/promises");
    5 const stream_1 = require("stream");
    6 const path_1 = require("path");
    7 function defaultOptions() {
    8     return {
    9         root: '.',
    10         fileFilter: (_path) => true,
    11         directoryFilter: (_path) => true,
    12         type: FILE_TYPE,
    13         lstat: false,
    14         depth: 2147483648,
    15         alwaysStat: false,
    16         highWaterMark: 4096,
    17     };
    18 }
     3exports.ReaddirpStream = exports.EntryTypes = void 0;
     4exports.readdirp = readdirp;
     5exports.readdirpPromise = readdirpPromise;
     6const promises_1 = require("node:fs/promises");
     7const node_stream_1 = require("node:stream");
     8const node_path_1 = require("node:path");
     9exports.EntryTypes = {
     10    FILE_TYPE: 'files',
     11    DIR_TYPE: 'directories',
     12    FILE_DIR_TYPE: 'files_directories',
     13    EVERYTHING_TYPE: 'all',
     14};
     15const defaultOptions = {
     16    root: '.',
     17    fileFilter: (_entryInfo) => true,
     18    directoryFilter: (_entryInfo) => true,
     19    type: exports.EntryTypes.FILE_TYPE,
     20    lstat: false,
     21    depth: 2147483648,
     22    alwaysStat: false,
     23    highWaterMark: 4096,
     24};
     25Object.freeze(defaultOptions);
    1926const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
    2027const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
    21 const FILE_TYPE = 'files';
    22 const DIR_TYPE = 'directories';
    23 const FILE_DIR_TYPE = 'files_directories';
    24 const EVERYTHING_TYPE = 'all';
    25 const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
    26 const DIR_TYPES = new Set([DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
    27 const FILE_TYPES = new Set([FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
     28const ALL_TYPES = [
     29    exports.EntryTypes.DIR_TYPE,
     30    exports.EntryTypes.EVERYTHING_TYPE,
     31    exports.EntryTypes.FILE_DIR_TYPE,
     32    exports.EntryTypes.FILE_TYPE,
     33];
     34const DIR_TYPES = new Set([
     35    exports.EntryTypes.DIR_TYPE,
     36    exports.EntryTypes.EVERYTHING_TYPE,
     37    exports.EntryTypes.FILE_DIR_TYPE,
     38]);
     39const FILE_TYPES = new Set([
     40    exports.EntryTypes.EVERYTHING_TYPE,
     41    exports.EntryTypes.FILE_DIR_TYPE,
     42    exports.EntryTypes.FILE_TYPE,
     43]);
    2844const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
    2945const wantBigintFsStats = process.platform === 'win32';
    30 const emptyFn = (_path) => true;
     46const emptyFn = (_entryInfo) => true;
    3147const normalizeFilter = (filter) => {
    3248    if (filter === undefined)
    … …  
    4460    return emptyFn;
    4561};
    46 class ReaddirpStream extends stream_1.Readable {
     62/** Readable readdir stream, emitting new files as they're being listed. */
     63class ReaddirpStream extends node_stream_1.Readable {
    4764    constructor(options = {}) {
    4865        super({
    … …  
    5168            highWaterMark: options.highWaterMark,
    5269        });
    53         const opts = { ...defaultOptions(), ...options };
     70        const opts = { ...defaultOptions, ...options };
    5471        const { root, type } = opts;
    5572        this._fileFilter = normalizeFilter(opts.fileFilter);
    … …  
    6380            this._stat = statMethod;
    6481        }
    65         this._maxDepth = opts.depth;
    66         this._wantsDir = DIR_TYPES.has(type);
    67         this._wantsFile = FILE_TYPES.has(type);
    68         this._wantsEverything = type === EVERYTHING_TYPE;
    69         this._root = (0, path_1.resolve)(root);
     82        this._maxDepth = opts.depth ?? defaultOptions.depth;
     83        this._wantsDir = type ? DIR_TYPES.has(type) : false;
     84        this._wantsFile = type ? FILE_TYPES.has(type) : false;
     85        this._wantsEverything = type === exports.EntryTypes.EVERYTHING_TYPE;
     86        this._root = (0, node_path_1.resolve)(root);
    7087        this._isDirent = !opts.alwaysStat;
    7188        this._statsProp = this._isDirent ? 'dirent' : 'stats';
    … …  
    147164        const basename = this._isDirent ? dirent.name : dirent;
    148165        try {
    149             const fullPath = (0, path_1.resolve)((0, path_1.join)(path, basename));
    150             entry = { path: (0, path_1.relative)(this._root, fullPath), fullPath, basename };
     166            const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename));
     167            entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename };
    151168            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
    152169        }
    … …  
    186203                if (entryRealPathStats.isDirectory()) {
    187204                    const len = entryRealPath.length;
    188                     if (full.startsWith(entryRealPath) && full.substr(len, 1) === path_1.sep) {
     205                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path_1.sep) {
    189206                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
    190207                        // @ts-ignore
    … …  
    208225exports.ReaddirpStream = ReaddirpStream;
    209226/**
    210  * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
     227 * Streaming version: Reads all files and directories in given root recursively.
     228 * Consumes ~constant small amount of RAM.
    211229 * @param root Root directory
    212230 * @param options Options to specify root (start directory), filters and recursion depth
    213231 */
    214 const readdirp = (root, options = {}) => {
     232function readdirp(root, options = {}) {
    215233    // @ts-ignore
    216234    let type = options.entryType || options.type;
    217235    if (type === 'both')
    218         type = FILE_DIR_TYPE; // backwards-compatibility
     236        type = exports.EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
    219237    if (type)
    220238        options.type = type;
    … …  
    230248    options.root = root;
    231249    return new ReaddirpStream(options);
    232 };
    233 exports.readdirp = readdirp;
    234 const readdirpPromise = (root, options = {}) => {
     250}
     251/**
     252 * Promise version: Reads all files and directories in given root recursively.
     253 * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
     254 * @returns array of paths and their entry infos
     255 */
     256function readdirpPromise(root, options = {}) {
    235257    return new Promise((resolve, reject) => {
    236258        const files = [];
    237         (0, exports.readdirp)(root, options)
     259        readdirp(root, options)
    238260            .on('data', (entry) => files.push(entry))
    239261            .on('end', () => resolve(files))
    240262            .on('error', (error) => reject(error));
    241263    });
    242 };
    243 exports.readdirpPromise = readdirpPromise;
    244 exports.default = exports.readdirp;
     264}
     265exports.default = readdirp;

  • imaps-frontend/node_modules/readdirp/package.json

    r0c6b92a r79a0317  
    11{
    2   "name": "readdirp",
    3   "description": "Recursive version of fs.readdir with streaming API.",
    4   "version": "4.0.2",
    5   "homepage": "https://github.com/paulmillr/readdirp",
    6   "repository": {
    7     "type": "git",
    8     "url": "git://github.com/paulmillr/readdirp.git"
     2  "_from": "readdirp@^4.0.1",
     3  "_id": "readdirp@4.1.1",
     4  "_inBundle": false,
     5  "_integrity": "sha512-h80JrZu/MHUZCyHu5ciuoI0+WxsCxzxJTILn6Fs8rxSnFPh+UVHYfeIxK1nVGugMqkfC4vJcBOYbkfkwYK0+gw==",
     6  "_location": "/readdirp",
     7  "_phantomChildren": {},
     8  "_requested": {
     9    "type": "range",
     10    "registry": true,
     11    "raw": "readdirp@^4.0.1",
     12    "name": "readdirp",
     13    "escapedName": "readdirp",
     14    "rawSpec": "^4.0.1",
     15    "saveSpec": null,
     16    "fetchSpec": "^4.0.1"
    917  },
    10   "license": "MIT",
     18  "_requiredBy": [
     19    "/chokidar"
     20  ],
     21  "_resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.1.tgz",
     22  "_shasum": "bd115327129672dc47f87408f05df9bd9ca3ef55",
     23  "_spec": "readdirp@^4.0.1",
     24  "_where": "/home/stevetosak/Proekt/IMaps/imaps-frontend/node_modules/chokidar",
     25  "author": {
     26    "name": "Thorsten Lorenz",
     27    "email": "thlorenz@gmx.de",
     28    "url": "thlorenz.com"
     29  },
    1130  "bugs": {
    1231    "url": "https://github.com/paulmillr/readdirp/issues"
    1332  },
    14   "author": "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
     33  "bundleDependencies": false,
    1534  "contributors": [
    16     "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
    17     "Paul Miller (https://paulmillr.com)"
     35    {
     36      "name": "Thorsten Lorenz",
     37      "email": "thlorenz@gmx.de",
     38      "url": "thlorenz.com"
     39    },
     40    {
     41      "name": "Paul Miller",
     42      "url": "https://paulmillr.com"
     43    }
    1844  ],
     45  "deprecated": false,
     46  "description": "Recursive version of fs.readdir with small RAM & CPU footprint.",
     47  "devDependencies": {
     48    "@paulmillr/jsbt": "0.2.1",
     49    "@types/node": "20.14.8",
     50    "c8": "10.1.3",
     51    "chai": "4.3.4",
     52    "chai-subset": "1.6.0",
     53    "micro-should": "0.4.0",
     54    "prettier": "3.1.1",
     55    "typescript": "5.5.2"
     56  },
    1957  "engines": {
    20     "node": ">= 14.16.0"
     58    "node": ">= 14.18.0"
     59  },
     60  "exports": {
     61    ".": {
     62      "import": "./esm/index.js",
     63      "require": "./index.js"
     64    }
    2165  },
    2266  "files": [
    … …  
    2771    "esm"
    2872  ],
    29   "main": "./index.js",
    30   "module": "./esm/index.js",
    31   "types": "./index.d.ts",
    32   "exports": {
    33     ".": {
    34       "import": "./esm/index.js",
    35       "require": "./index.js"
    36     }
     73  "funding": {
     74    "type": "individual",
     75    "url": "https://paulmillr.com/funding/"
    3776  },
    38   "sideEffects": false,
     77  "homepage": "https://github.com/paulmillr/readdirp",
    3978  "keywords": [
    4079    "recursive",
    … …  
    4786    "filter"
    4887  ],
     88  "license": "MIT",
     89  "main": "./index.js",
     90  "module": "./esm/index.js",
     91  "name": "readdirp",
     92  "repository": {
     93    "type": "git",
     94    "url": "git://github.com/paulmillr/readdirp.git"
     95  },
    4996  "scripts": {
    5097    "build": "tsc && tsc -p tsconfig.esm.json",
    51     "nyc": "nyc",
    52     "mocha": "mocha --exit",
    53     "lint": "prettier --check index.ts",
    54     "format": "prettier --write index.ts",
    55     "test": "nyc npm run mocha"
     98    "format": "prettier --write index.ts test/index.test.js",
     99    "lint": "prettier --check index.ts test/index.test.js",
     100    "test": "node test/index.test.js",
     101    "test:coverage": "c8 node test/index.test.js"
    56102  },
    57   "devDependencies": {
    58     "@paulmillr/jsbt": "0.2.1",
    59     "@types/node": "20.14.8",
    60     "chai": "4.3.4",
    61     "chai-subset": "1.6.0",
    62     "mocha": "10.7.3",
    63     "nyc": "15.0.1",
    64     "prettier": "3.1.1",
    65     "rimraf": "6.0.1",
    66     "typescript": "5.5.2"
    67   },
    68   "nyc": {
    69     "reporter": [
    70       "html",
    71       "text"
    72     ]
    73   },
    74   "funding": {
    75     "type": "individual",
    76     "url": "https://paulmillr.com/funding/"
    77   }
     103  "sideEffects": false,
     104  "types": "./index.d.ts",
     105  "version": "4.1.1"
    78106}
Note: See TracChangeset for help on using the changeset viewer.