devbrain-cli 0.2.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodable/entities/src/entityTries.js

@@ -0,0 +1,49 @@
+// entityTries.js
+// Builds integer-keyed tries so the decoder never allocates a string object
+// during lookup — every key is a plain charCode number.
+//
+// trie1: Map<code0, entity>
+// trie2: Map<code0, Map<code1, entity>>
+// trie3: Map<code0, Map<code1, Map<code2, entity>>>
+
+import { ALL_ENTITIES } from './entities.js';
+
+// Reverse map: character sequence → "&name;"
+const CHAR_TO_ENTITY = new Map();
+for (const [name, chars] of Object.entries(ALL_ENTITIES)) {
+  CHAR_TO_ENTITY.set(chars, `&${name};`);
+}
+
+export const trie1 = new Map();   // code0          → entity string
+export const trie2 = new Map();   // code0 → Map    → entity string
+export const trie3 = new Map();   // code0 → Map → Map → entity string
+
+for (const [chars, entity] of CHAR_TO_ENTITY) {
+  const len = chars.length;
+
+  if (len === 1) {
+    const c0 = chars.charCodeAt(0);
+    // Keep shortest match only if no longer match already claimed this code
+    // (longer matches are inserted in the same pass so we just overwrite —
+    //  trie1 is only consulted after trie2/trie3 both miss, so no conflict)
+    trie1.set(c0, entity);
+
+  } else if (len === 2) {
+    const c0 = chars.charCodeAt(0);
+    const c1 = chars.charCodeAt(1);
+    let inner = trie2.get(c0);
+    if (inner === undefined) { inner = new Map(); trie2.set(c0, inner); }
+    inner.set(c1, entity);
+
+  } else if (len === 3) {
+    const c0 = chars.charCodeAt(0);
+    const c1 = chars.charCodeAt(1);
+    const c2 = chars.charCodeAt(2);
+    let mid = trie3.get(c0);
+    if (mid === undefined) { mid = new Map(); trie3.set(c0, mid); }
+    let inner = mid.get(c1);
+    if (inner === undefined) { inner = new Map(); mid.set(c1, inner); }
+    inner.set(c2, entity);
+  }
+  // HTML5 has no named entity whose character sequence is longer than 3 chars
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodable/entities/src/index.d.ts

@@ -0,0 +1,341 @@
+// ---------------------------------------------------------------------------
+// @nodable/entities — TypeScript declarations
+// ---------------------------------------------------------------------------
+
+/** A function-based entity replacement value (used for numeric refs). */
+export type EntityValFn = (match: string, captured: string, ...rest: unknown[]) => string;
+
+// ---------------------------------------------------------------------------
+// Entity registration hook
+// ---------------------------------------------------------------------------
+
+/**
+ * Actions returned by `onExternalEntity` / `onInputEntity` hooks.
+ * Use the `ENTITY_ACTION` constant object instead of raw strings to avoid typos.
+ *
+ * - `'allow'` — register and expand the entity normally
+ * - `'block'` — silently skip the entity (not registered, treated as unknown)
+ * - `'throw'` — abort registration with an error
+ */
+export type EntityHookAction = 'allow' | 'block' | 'throw';
+
+/**
+ * Immutable constant bag for entity registration hook return values.
+ *
+ * @example
+ * import { ENTITY_ACTION } from '@nodable/entities';
+ * const dec = new EntityDecoder({
+ *   onInputEntity: (_name, _value) => ENTITY_ACTION.BLOCK,
+ * });
+ */
+export const ENTITY_ACTION: Readonly<{
+  /** Register and expand the entity normally. */
+  ALLOW: 'allow';
+  /** Silently skip this entity — it will not be registered. */
+  BLOCK: 'block';
+  /** Throw an error, aborting entity registration. */
+  THROW: 'throw';
+}>;
+
+/**
+ * Callback signature for `onExternalEntity` and `onInputEntity` hooks.
+ *
+ * Called once per entity **at registration time** (not at decode time).
+ * Return `ENTITY_ACTION.ALLOW` (or `'allow'`) to accept, `ENTITY_ACTION.BLOCK`
+ * to silently skip, or `ENTITY_ACTION.THROW` to raise an error.
+ *
+ * @param name  — the entity name without `&` / `;`, e.g. `"brand"`
+ * @param value — the resolved string value after any `{regex,val}` unwrapping
+ */
+export type EntityRegistrationHook = (name: string, value: string) => EntityHookAction;
+
+// ---------------------------------------------------------------------------
+// Encoder options
+// ---------------------------------------------------------------------------
+
+export interface EntityEncoderOptions {
+  /**
+   * Whether to encode XML unsafe characters: `&`, `<`, `>`, `"`, `'`.
+   * @default true
+   */
+  encodeXmlSafe?: boolean;
+
+  /**
+   * Whether to encode non‑ASCII characters (e.g. `é` → `&eacute;`) using the
+   * built‑in named entity trie.
+   * @default true
+   */
+  encodeAllNamed?: boolean;
+
+  /**
+   * Maximum number of replacements performed **cumulatively** across all
+   * `encode()` calls. `0` means unlimited.
+   *
+   * Use `reset()` to reset the internal counter.
+   * @default 0
+   */
+  maxReplacements?: number;
+}
+
+// ---------------------------------------------------------------------------
+// EntityEncoder class
+// ---------------------------------------------------------------------------
+
+/**
+ * High‑performance encoder that replaces characters with XML/HTML entities.
+ *
+ * - Escapes XML unsafe characters (`&`, `<`, `>`, `"`, `'`) when `encodeXmlSafe` is true.
+ * - Replaces non‑ASCII characters (e.g. `é`, `©`) with named entities using
+ *   a compact trie‑based lookup when `encodeAllNamed` is true.
+ * - Supports a cumulative replacement limit (`maxReplacements`) that persists
+ *   across multiple `encode()` calls until `reset()` is called.
+ *
+ * @example
+ * const encoder = new EntityEncoder({ encodeXmlSafe: true, encodeAllNamed: true });
+ * encoder.encode('<foo>');   // "&lt;foo&gt;"
+ * encoder.encode('© 2025');  // "&copy; 2025"
+ *
+ * // With limit
+ * const limited = new EntityEncoder({ maxReplacements: 2 });
+ * limited.encode('<>&');     // "&lt;&gt;&"  (third replacement omitted)
+ * limited.reset();           // reset counter
+ */
+export class EntityEncoder {
+  constructor(options?: EntityEncoderOptions);
+
+  /**
+   * Encode a string by replacing XML‑unsafe characters and (optionally)
+   * non‑ASCII characters with named entities.
+   *
+   * If `maxReplacements` is set and the cumulative limit has been reached,
+   * the input string is returned unchanged.
+   *
+   * @returns Encoded string (may be identical to input if no replacements needed
+   *          or the limit has been exhausted).
+   */
+  encode(str: string): string;
+
+  /**
+   * Reset the internal replacement counter.
+   * Does **not** change `encodeXmlSafe`, `encodeAllNamed`, or `maxReplacements`.
+   */
+  reset(): void;
+}
+
+// ---------------------------------------------------------------------------
+// Constructor options for EntityDecoder (existing)
+// ---------------------------------------------------------------------------
+
+/**
+ * Controls which entity categories count toward the expansion limits.
+ *
+ * - `'external'` — only untrusted / injected entities (default)
+ * - `'base'`     — only built‑in XML entities + user‑supplied `namedEntities`
+ * - `'all'`      — all entities regardless of tier
+ * - `string[]`   — explicit combination, e.g. `['external', 'base']`
+ */
+export type ApplyLimitsTo = 'external' | 'base' | 'all' | Array<'external' | 'base'>;
+
+export interface EntityDecoderLimitOptions {
+  /**
+   * Maximum number of entity references expanded **per document**.
+   * `0` means unlimited.
+   * @default 0
+   */
+  maxTotalExpansions?: number;
+
+  /**
+   * Maximum number of characters **added** by entity expansion per document.
+   * `0` means unlimited.
+   * @default 0
+   */
+  maxExpandedLength?: number;
+
+  /**
+   * Which entity tiers count toward the expansion limits.
+   *
+   * - `'external'` (default) – only input/runtime + persistent external entities
+   * - `'base'`               – only built‑in XML + `namedEntities`
+   * - `'all'`                – every entity regardless of tier
+   * - `string[]`             – explicit combination, e.g. `['external', 'base']`
+   *
+   * @default 'external'
+   */
+  applyLimitsTo?: ApplyLimitsTo;
+}
+
+export interface EntityDecoderNCROptions {
+  /**
+   * XML version used for NCR classification.
+   * @default 1.0
+   */
+  xmlVersion?: 1.0 | 1.1;
+
+  /**
+   * Base action for all numeric references.
+   * @default 'allow'
+   */
+  onNCR?: 'allow' | 'leave' | 'remove' | 'throw';
+
+  /**
+   * Action for null NCR (U+0000).
+   * @default 'remove'
+   */
+  nullNCR?: 'remove' | 'throw';
+}
+
+export interface EntityDecoderOptions {
+  /**
+   * Extra named entities merged into the **base map** (trusted, counts as `'base'` tier).
+   * These are combined with the built‑in XML entities (`lt`, `gt`, `quot`, `apos`).
+   * Values containing `&` are silently skipped to prevent recursive expansion.
+   *
+   * @default null
+   */
+  namedEntities?: Record<string, string | { regex: RegExp; val: string | EntityValFn }> | null;
+
+
+  /**
+   * Hook called once on the fully decoded string (after all replacements).
+   *
+   * - Receives `(resolved, original)` and **must return a string**.
+   * - To reject expansion, return `original`.
+   * - To sanitize, return a cleaned version of `resolved`.
+   *
+   * @example
+   * postCheck: (resolved, original) =>
+   *   /<[a-z]/i.test(resolved) ? original : resolved
+   */
+  postCheck?: ((resolved: string, original: string) => string) | null;
+
+  /**
+   * Whether numeric character references (`&#NNN;`, `&#xHH;`) are allowed.
+   * @default true
+   */
+  numericAllowed?: boolean;
+
+  /**
+   * Array of entity names or numeric references to leave unexpanded.
+   * @default []
+   */
+  leave?: string[];
+
+  /**
+   * Array of entity names or numeric references to remove.
+   * @default []
+   */
+  remove?: string[];
+
+  /**
+   * Security limits for entity expansion.
+   */
+  limit?: EntityDecoderLimitOptions;
+
+  /**
+   * Numeric Character Reference (NCR) policy.
+   */
+  ncr?: EntityDecoderNCROptions;
+
+  /**
+   * Hook called once **at registration time** for each entity passed to
+   * `setExternalEntities()` or `addExternalEntity()`.
+   *
+   * - `'allow'` (or `ENTITY_ACTION.ALLOW`) — register the entity normally (default)
+   * - `'block'` (or `ENTITY_ACTION.BLOCK`) — silently skip; the entity is not stored
+   * - `'throw'` (or `ENTITY_ACTION.THROW`) — abort registration with an `Error`
+   *
+   * The hook receives the entity name (without `&`/`;`) and the resolved string
+   * value. It is **not** called during `decode()` — only when entities are added.
+   *
+   * @example
+   * const dec = new EntityDecoder({
+   *   onExternalEntity: (name, value) =>
+   *     DANGEROUS_NAMES.has(name) ? ENTITY_ACTION.BLOCK : ENTITY_ACTION.ALLOW,
+   * });
+   */
+  onExternalEntity?: EntityRegistrationHook | null;
+
+  /**
+   * Hook called once **at registration time** for each entity passed to
+   * `addInputEntities()`.
+   *
+   * Follows the same `'allow' | 'block' | 'throw'` contract as `onExternalEntity`.
+   *
+   * @example
+   * const dec = new EntityDecoder({
+   *   // Block all input / DOCTYPE entities unconditionally
+   *   onInputEntity: () => ENTITY_ACTION.BLOCK,
+   * });
+   */
+  onInputEntity?: EntityRegistrationHook | null;
+}
+
+// ---------------------------------------------------------------------------
+// EntityDecoder class (default export)
+// ---------------------------------------------------------------------------
+
+/**
+ * Single‑pass, zero‑regex entity decoder for XML/HTML content.
+ *
+ * ## Entity lookup priority (highest → lowest)
+ * 1. **input / runtime** – injected via `addInputEntities()` (DOCTYPE per document)
+ * 2. **persistent external** – set via `setExternalEntities()` / `addExternalEntity()`
+ * 3. **base map** – built‑in XML entities + user‑supplied `namedEntities`
+ *
+ * Numeric references (`&#NNN;`, `&#xHH;`) are resolved directly and count as the `'base'` tier.
+ *
+ * @example
+ * const decoder = new EntityDecoder({
+ *   namedEntities: COMMON_HTML,
+ *   maxTotalExpansions: 100
+ * });
+ * decoder.setExternalEntities({ brand: 'Acme' });
+ *
+ * decoder.addInputEntities({ version: '1.0' });
+ * decoder.decode('&brand; v&version; &lt;'); // 'Acme v1.0 <'
+ *
+ * decoder.reset(); // clears input entities + counters, keeps external entities
+ */
+export default class EntityDecoder {
+  constructor(options?: EntityDecoderOptions);
+
+  setExternalEntities(
+    map: Record<string, string | { regex: RegExp; val: string | EntityValFn }>
+  ): void;
+
+  addExternalEntity(key: string, value: string): void;
+
+  addInputEntities(
+    map: Record<
+      string,
+      | string
+      | { regx: RegExp; val: string | EntityValFn }
+      | { regex: RegExp; val: string | EntityValFn }
+    >
+  ): void;
+
+  reset(): this;
+
+  decode(str: string): string;
+}
+
+// ---------------------------------------------------------------------------
+// Named entity group exports (for use with `namedEntities` option)
+// ---------------------------------------------------------------------------
+
+export const COMMON_HTML: Record<string, string>;
+export const ALL_ENTITIES: Record<string, string>;
+export const XML: Record<string, string>;
+export const BASIC_LATIN: Record<string, string>;
+export const LATIN_ACCENTS: Record<string, string>;
+export const LATIN_EXTENDED: Record<string, string>;
+export const GREEK: Record<string, string>;
+export const CYRILLIC: Record<string, string>;
+export const MATH: Record<string, string>;
+export const MATH_ADVANCED: Record<string, string>;
+export const ARROWS: Record<string, string>;
+export const SHAPES: Record<string, string>;
+export const PUNCTUATION: Record<string, string>;
+export const CURRENCY: Record<string, string>;
+export const FRACTIONS: Record<string, string>;
+export const MISC_SYMBOLS: Record<string, string>;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodable/entities/src/index.js

@@ -0,0 +1,29 @@
+/**
+ * @nodable/entities
+ *
+ * Standalone, zero-dependency XML/HTML entity replacement.
+ *
+
+ */
+
+export { default as EntityDecoder, ENTITY_ACTION } from './EntityDecoder.js';
+export {
+  COMMON_HTML,
+  XML,
+  ALL_ENTITIES,
+  ARROWS,
+  BASIC_LATIN,
+  CURRENCY,
+  MATH,
+  MATH_ADVANCED,
+  CYRILLIC,
+  FRACTIONS,
+  GREEK,
+  LATIN_ACCENTS,
+  LATIN_EXTENDED,
+  MISC_SYMBOLS,
+  PUNCTUATION,
+  SHAPES,
+} from './entities.js';
+
+export { default as EntityEncoder } from './EntityEncoder.js';

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/README.md

@@ -0,0 +1,171 @@
+# @nodelib/fs.scandir
+
+> List files and directories inside the specified directory.
+
+## :bulb: Highlights
+
+The package is aimed at obtaining information about entries in the directory.
+
+* :moneybag: Returns useful information: `name`, `path`, `dirent` and `stats` (optional).
+* :gear: On Node.js 10.10+ uses the mechanism without additional calls to determine the entry type. See [`old` and `modern` mode](#old-and-modern-mode).
+* :link: Can safely work with broken symbolic links.
+
+## Install
+
+```console
+npm install @nodelib/fs.scandir
+```
+
+## Usage
+
+```ts
+import * as fsScandir from '@nodelib/fs.scandir';
+
+fsScandir.scandir('path', (error, stats) => { /* … */ });
+```
+
+## API
+
+### .scandir(path, [optionsOrSettings], callback)
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path with standard callback-style.
+
+```ts
+fsScandir.scandir('path', (error, entries) => { /* … */ });
+fsScandir.scandir('path', {}, (error, entries) => { /* … */ });
+fsScandir.scandir('path', new fsScandir.Settings(), (error, entries) => { /* … */ });
+```
+
+### .scandirSync(path, [optionsOrSettings])
+
+Returns an array of plain objects ([`Entry`](#entry)) with information about entry for provided path.
+
+```ts
+const entries = fsScandir.scandirSync('path');
+const entries = fsScandir.scandirSync('path', {});
+const entries = fsScandir.scandirSync(('path', new fsScandir.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settingsoptions) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsScandir.Settings({ followSymbolicLinks: false });
+
+const entries = fsScandir.scandirSync('path', settings);
+```
+
+## Entry
+
+* `name` — The name of the entry (`unknown.txt`).
+* `path` — The path of the entry relative to call directory (`root/unknown.txt`).
+* `dirent` — An instance of [`fs.Dirent`](./src/types/index.ts) class. On Node.js below 10.10 will be emulated by [`DirentFromStats`](./src/utils/fs.ts) class.
+* `stats` (optional) — An instance of `fs.Stats` class.
+
+For example, the `scandir` call for `tools` directory with one directory inside:
+
+```ts
+{
+	dirent: Dirent { name: 'typedoc', /* … */ },
+	name: 'typedoc',
+	path: 'tools/typedoc'
+}
+```
+
+## Options
+
+### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Adds an instance of `fs.Stats` class to the [`Entry`](#entry).
+
+> :book: Always use `fs.readdir` without the `withFileTypes` option. ??TODO??
+
+### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `false`
+
+Follow symbolic links or not. Call `fs.stat` on symbolic link if `true`.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely use `lstat` call if `false`.
+
+### `pathSegmentSeparator`
+
+* Type: `string`
+* Default: `path.sep`
+
+By default, this package uses the correct path separator for your OS (`\` on Windows, `/` on Unix-like systems). But you can set this option to any separator character(s) that you want to use instead.
+
+### `fs`
+
+* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+	lstat?: typeof fs.lstat;
+	stat?: typeof fs.stat;
+	lstatSync?: typeof fs.lstatSync;
+	statSync?: typeof fs.statSync;
+	readdir?: typeof fs.readdir;
+	readdirSync?: typeof fs.readdirSync;
+}
+
+const settings = new fsScandir.Settings({
+	fs: { lstat: fakeLstat }
+});
+```
+
+## `old` and `modern` mode
+
+This package has two modes that are used depending on the environment and parameters of use.
+
+### old
+
+* Node.js below `10.10` or when the `stats` option is enabled
+
+When working in the old mode, the directory is read first (`fs.readdir`), then the type of entries is determined (`fs.lstat` and/or `fs.stat` for symbolic links).
+
+### modern
+
+* Node.js 10.10+ and the `stats` option is disabled
+
+In the modern mode, reading the directory (`fs.readdir` with the `withFileTypes` option) is combined with obtaining information about its entries. An additional call for symbolic links (`fs.stat`) is still present.
+
+This mode makes fewer calls to the file system. It's faster.
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/out/adapters/fs.d.ts

@@ -0,0 +1,20 @@
+import type * as fsStat from '@nodelib/fs.stat';
+import type { Dirent, ErrnoException } from '../types';
+export interface ReaddirAsynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
+    (filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
+}
+export interface ReaddirSynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }): Dirent[];
+    (filepath: string): string[];
+}
+export declare type FileSystemAdapter = fsStat.FileSystemAdapter & {
+    readdir: ReaddirAsynchronousMethod;
+    readdirSync: ReaddirSynchronousMethod;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/out/adapters/fs.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/out/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+export declare const IS_SUPPORT_READDIR_WITH_FILE_TYPES: boolean;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/out/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+}
+const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@nodelib/fs.scandir/out/index.d.ts

@@ -0,0 +1,12 @@
+import type { FileSystemAdapter, ReaddirAsynchronousMethod, ReaddirSynchronousMethod } from './adapters/fs';
+import * as async from './providers/async';
+import Settings, { Options } from './settings';
+import type { Dirent, Entry } from './types';
+declare type AsyncCallback = async.AsyncCallback;
+declare function scandir(path: string, callback: AsyncCallback): void;
+declare function scandir(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
+declare namespace scandir {
+    function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Entry[]>;
+}
+declare function scandirSync(path: string, optionsOrSettings?: Options | Settings): Entry[];
+export { scandir, scandirSync, Settings, AsyncCallback, Dirent, Entry, FileSystemAdapter, ReaddirAsynchronousMethod, ReaddirSynchronousMethod, Options };