modified

node_modules/@adonisjs/repl/build/adonis-typings/container.d.ts

@@ -0,0 +1,6 @@
+declare module '@ioc:Adonis/Core/Application' {
+    import { ReplContract } from '@ioc:Adonis/Addons/Repl';
+    interface ContainerBindings {
+        'Adonis/Addons/Repl': ReplContract;
+    }
+}

node_modules/@adonisjs/repl/build/adonis-typings/container.js

@@ -0,0 +1,8 @@
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */

node_modules/@adonisjs/repl/build/adonis-typings/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="container.d.ts" />
+/// <reference path="repl.d.ts" />

node_modules/@adonisjs/repl/build/adonis-typings/index.js

@@ -0,0 +1,10 @@
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/// <reference path="./container.ts" />
+/// <reference path="./repl.ts" />

node_modules/@adonisjs/repl/build/adonis-typings/repl.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+declare module '@ioc:Adonis/Addons/Repl' {
+    import { REPLServer } from 'repl';
+    import { getBest } from '@poppinss/colors';
+    /**
+     * Custom method callback
+     */
+    export type Handler = (repl: ReplContract, ...args: any[]) => any;
+    /**
+     * Options that can be set when defining a loader
+     * method
+     */
+    export type ContextOptions = {
+        description?: string;
+        usage?: string;
+    };
+    /**
+     * Shape of the REPL class
+     */
+    export interface ReplContract {
+        colors: ReturnType<typeof getBest>;
+        /**
+         * Reference to the REPL server
+         */
+        server: REPLServer;
+        /**
+         * Start the repl
+         */
+        start(): this;
+        /**
+         * Notify by writing message to the console
+         * and resuming the prompt
+         */
+        notify(message: string): void;
+        /**
+         * Add a method. Loader methods works as a shortcut for
+         */
+        addMethod(name: string, handler: Handler, options?: ContextOptions): this;
+        /**
+         * Register a callback to be invoked once the server is ready
+         */
+        ready(callback: (repl: ReplContract) => void): this;
+    }
+    const Repl: ReplContract;
+    export default Repl;
+}

node_modules/@adonisjs/repl/build/adonis-typings/repl.js

@@ -0,0 +1,8 @@
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */

node_modules/@adonisjs/repl/build/commands/AdonisRepl.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '@adonisjs/core/build/standalone';
+export default class ReplCommand extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static settings: {
+        loadApp: boolean;
+        environment: "repl";
+        stayAlive: boolean;
+    };
+    run(): Promise<void>;
+}

node_modules/@adonisjs/repl/build/commands/AdonisRepl.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const standalone_1 = require("@adonisjs/core/build/standalone");
+class ReplCommand extends standalone_1.BaseCommand {
+    async run() {
+        this.application.container.withBindings(['Adonis/Core/Route'], (Route) => {
+            Route.commit();
+        });
+        this.application.container.use('Adonis/Addons/Repl').start();
+        /**
+         * Gracefully shutdown the application
+         */
+        this.application.container.use('Adonis/Addons/Repl').server.on('exit', async () => {
+            await this.application.shutdown();
+        });
+    }
+}
+exports.default = ReplCommand;
+ReplCommand.commandName = 'repl';
+ReplCommand.description = 'Start a new REPL session';
+ReplCommand.settings = {
+    loadApp: true,
+    environment: 'repl',
+    stayAlive: true,
+};

node_modules/@adonisjs/repl/build/commands/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

node_modules/@adonisjs/repl/build/commands/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ['@adonisjs/repl/build/commands/AdonisRepl'];

node_modules/@adonisjs/repl/build/providers/ReplProvider.d.ts

@@ -0,0 +1,7 @@
+import { ApplicationContract } from '@ioc:Adonis/Core/Application';
+export default class ReplProvider {
+    protected app: ApplicationContract;
+    constructor(app: ApplicationContract);
+    static needsApplication: boolean;
+    register(): void;
+}

node_modules/@adonisjs/repl/build/providers/ReplProvider.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+class ReplProvider {
+    constructor(app) {
+        this.app = app;
+    }
+    register() {
+        this.app.container.singleton('Adonis/Addons/Repl', () => {
+            const compiler = global[Symbol.for('REQUIRE_TS_COMPILER')];
+            const { Repl } = require('../src/Repl');
+            return new Repl(compiler, (0, path_1.join)((0, os_1.homedir)(), '.adonis_repl_history'));
+        });
+    }
+}
+exports.default = ReplProvider;
+ReplProvider.needsApplication = true;

node_modules/@adonisjs/repl/build/src/Compiler/index.d.ts

@@ -0,0 +1,29 @@
+import { Compiler as TsCompiler } from '@adonisjs/require-ts/build/src/Compiler';
+/**
+ * Exposes the API to compile the user land code to be executed
+ * inside Node.JS REPL.
+ */
+export declare class Compiler {
+    private tsCompiler?;
+    compilesTs: boolean;
+    constructor(tsCompiler?: TsCompiler | undefined);
+    /**
+     * Process the await keywords in the code
+     */
+    private processAwait;
+    /**
+     * Compiles code using typescript
+     */
+    private compileTypescript;
+    /**
+     * Compiles the code to be executed in the Node.js REPL. Under
+     * the hood
+     *
+     * - Typescript code is compiled
+     * - Await keywords are wrapped in async IIFE
+     */
+    compile(statement: string, filename: string): Promise<{
+        compiled: string;
+        awaitPromise: boolean;
+    }>;
+}

node_modules/@adonisjs/repl/build/src/Compiler/index.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+const node_repl_await_1 = require("node-repl-await");
+const ImportsParser_1 = require("../ImportsParser");
+/**
+ * Exposes the API to compile the user land code to be executed
+ * inside Node.JS REPL.
+ */
+class Compiler {
+    constructor(tsCompiler) {
+        this.tsCompiler = tsCompiler;
+        this.compilesTs = !!this.tsCompiler;
+    }
+    /**
+     * Process the await keywords in the code
+     */
+    processAwait(statement) {
+        const potentialWrappedCode = (0, node_repl_await_1.processTopLevelAwait)(statement);
+        if (!potentialWrappedCode) {
+            return { compiled: statement, awaitPromise: false };
+        }
+        return { compiled: potentialWrappedCode, awaitPromise: true };
+    }
+    /**
+     * Compiles code using typescript
+     */
+    async compileTypescript(statement, filename) {
+        const lines = statement.split(/\n|\r\n/);
+        let compiledOutput = statement;
+        /**
+         * In case of a single line, we process the import
+         * keywords and define local variables to hold
+         * the import reference
+         */
+        if (lines.length <= 2) {
+            compiledOutput = await new ImportsParser_1.ImportsParser().parse(statement);
+        }
+        /**
+         * Compile using typescript compiler and patch the
+         * `sourceMappingUrl` comment to be a block level comment.
+         */
+        compiledOutput = this.tsCompiler.compile(filename, compiledOutput, true);
+        return `${compiledOutput.replace('//# sourceMappingURL=', '/**# sourceMappingURL=')} */`;
+    }
+    /**
+     * Compiles the code to be executed in the Node.js REPL. Under
+     * the hood
+     *
+     * - Typescript code is compiled
+     * - Await keywords are wrapped in async IIFE
+     */
+    async compile(statement, filename) {
+        if (this.tsCompiler) {
+            statement = await this.compileTypescript(statement, filename);
+        }
+        return this.processAwait(statement);
+    }
+}
+exports.Compiler = Compiler;

node_modules/@adonisjs/repl/build/src/ImportsParser/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This is a crazy attempt to hack around the Typescript behavior around un-used
+ * imports. Writing half baked parsers is something I want to avoid everytime.
+ * However, there isn't any other way (atleast I don't know about it).
+ *
+ * In REPL, you usually write one line of code at a time. For example:
+ * - You write 2 + 2 and then press enter. The REPL prints 4
+ * - You write `await Database.query().first()` and it prints the query result.
+ *
+ * However, when you write `import User from 'App/Models/User'` and expect to
+ * access User variable then you are out of luck.
+ *
+ * - The import statement will go to the typescript compiler
+ * - It will compile the code and sees that no one is using this import.
+ *   And hence it will just remove it from the compiled output.
+ *
+ * Bang! No import/require exists and hence no `User` variable exists.
+ *
+ * To hack around it, we need to monitor and parse import statements and hold
+ * a reference to them so that the compiler doesn't remove. For example:
+ *
+ * Converting
+ * ```ts
+ * 	import User from 'App/Models/User'
+ * ```
+ *
+ * To
+ * ```ts
+ * 	import repl_User from 'App/Models/User'; var User = repl_User
+ * ```
+ *
+ * Now you can access the `User` variable.
+ *
+ * The tough part is attempting to parse all styles in which an import
+ * statement can be written. Lucikly, there are 4 different ways to
+ * do that as per the spec http://www.ecma-international.org/ecma-262/6.0/#table-40
+ *
+ * 		import v from "mod";									(Import default)
+ * 		import * as ns from "mod";						(Import alias)
+ * 		import {x} from "mod";								(Import named)
+ * 		import {x as v} from "mod";						(Import named + aliases)
+ *
+ * However, we have to be tolerant to the white spaces.
+ */
+export declare class ImportsParser {
+    private parseImport;
+    /**
+     * Parse a given line of code
+     */
+    parse(line: string): Promise<string>;
+}

node_modules/@adonisjs/repl/build/src/ImportsParser/index.js

@@ -0,0 +1,137 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportsParser = void 0;
+const parse_imports_1 = __importDefault(require("parse-imports"));
+/**
+ * This is a crazy attempt to hack around the Typescript behavior around un-used
+ * imports. Writing half baked parsers is something I want to avoid everytime.
+ * However, there isn't any other way (atleast I don't know about it).
+ *
+ * In REPL, you usually write one line of code at a time. For example:
+ * - You write 2 + 2 and then press enter. The REPL prints 4
+ * - You write `await Database.query().first()` and it prints the query result.
+ *
+ * However, when you write `import User from 'App/Models/User'` and expect to
+ * access User variable then you are out of luck.
+ *
+ * - The import statement will go to the typescript compiler
+ * - It will compile the code and sees that no one is using this import.
+ *   And hence it will just remove it from the compiled output.
+ *
+ * Bang! No import/require exists and hence no `User` variable exists.
+ *
+ * To hack around it, we need to monitor and parse import statements and hold
+ * a reference to them so that the compiler doesn't remove. For example:
+ *
+ * Converting
+ * ```ts
+ * 	import User from 'App/Models/User'
+ * ```
+ *
+ * To
+ * ```ts
+ * 	import repl_User from 'App/Models/User'; var User = repl_User
+ * ```
+ *
+ * Now you can access the `User` variable.
+ *
+ * The tough part is attempting to parse all styles in which an import
+ * statement can be written. Lucikly, there are 4 different ways to
+ * do that as per the spec http://www.ecma-international.org/ecma-262/6.0/#table-40
+ *
+ * 		import v from "mod";									(Import default)
+ * 		import * as ns from "mod";						(Import alias)
+ * 		import {x} from "mod";								(Import named)
+ * 		import {x as v} from "mod";						(Import named + aliases)
+ *
+ * However, we have to be tolerant to the white spaces.
+ */
+class ImportsParser {
+    async parseImport(statement) {
+        statement = statement.trim();
+        /**
+         * Return the value as it is when doesn't include the import
+         * keyword
+         */
+        if (!statement.startsWith('import')) {
+            return statement;
+        }
+        /**
+         * Parse all imports in the current line
+         */
+        const imports = await (0, parse_imports_1.default)(statement);
+        const importsAsArray = [...imports];
+        return importsAsArray
+            .map(({ moduleSpecifier, importClause }) => {
+            const tokens = [];
+            const localVariables = [];
+            /**
+             * Has `* as` namespace import
+             */
+            if (importClause && importClause.namespace) {
+                const identifier = `repl_${importClause.namespace}`;
+                tokens.push(`* as ${identifier}`);
+                localVariables.push(`var ${importClause.namespace} = ${identifier}`);
+            }
+            /**
+             * Has default namespace import
+             */
+            if (importClause && importClause.default) {
+                const identifier = `repl_${importClause.default}`;
+                tokens.push(identifier);
+                localVariables.push(`var ${importClause.default} = ${identifier}`);
+            }
+            /**
+             * Has named imports
+             */
+            if (importClause && importClause.named.length) {
+                importClause.named.forEach((name, index) => {
+                    const identifier = `repl_${name.binding}`;
+                    let expression = '';
+                    /**
+                     * Add starting curly brace to named aliases
+                     */
+                    if (index === 0) {
+                        expression += '{';
+                    }
+                    /**
+                     * Setup expression
+                     */
+                    expression += `${name.specifier} as ${identifier}`;
+                    /**
+                     * Add ending curly brace to named aliases
+                     */
+                    if (index + 1 === importClause.named.length) {
+                        expression += '}';
+                    }
+                    tokens.push(expression);
+                    localVariables.push(`var ${name.binding} = ${identifier}`);
+                });
+            }
+            const localVariablesDeclaration = `${localVariables.join('; ')}`;
+            return `import ${tokens.join(',')} from ${moduleSpecifier.code}; ${localVariablesDeclaration}`;
+        })
+            .join('');
+    }
+    /**
+     * Parse a given line of code
+     */
+    async parse(line) {
+        const parsedStatement = await Promise.all(line.split(';').map((statement) => {
+            return this.parseImport(statement);
+        }));
+        return parsedStatement.join('; ');
+    }
+}
+exports.ImportsParser = ImportsParser;

node_modules/@adonisjs/repl/build/src/Repl/index.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="node" />
+import { REPLServer } from 'repl';
+import { ReplContract, Handler, ContextOptions } from '@ioc:Adonis/Addons/Repl';
+import { Compiler as TsCompiler } from '@adonisjs/require-ts/build/src/Compiler';
+/**
+ * Exposes the API to work the REPL server
+ */
+export declare class Repl implements ReplContract {
+    private tsCompiler?;
+    private historyFilePath?;
+    /**
+     * Compiler to compile REPL input
+     */
+    private compiler;
+    /**
+     * Length of the longest custom method name. We need to show a
+     * symmetric view of custom methods and their description
+     */
+    private longestCustomMethodName;
+    /**
+     * Set of registered ready callbacks
+     */
+    private onReadyCallbacks;
+    /**
+     * A set of registered custom methods
+     */
+    private customMethods;
+    /**
+     * Reference to the underlying REPL server. Available
+     * after `start` is invoked.
+     */
+    server: REPLServer;
+    /**
+     * Reference to the colors to print colorful messages
+     */
+    colors: import("@poppinss/colors/build/src/Base").Colors;
+    constructor(tsCompiler?: TsCompiler | undefined, historyFilePath?: string | undefined);
+    /**
+     * Find if the error is recoverable or not
+     */
+    private isRecoverableError;
+    /**
+     * Custom eval method to execute the user code
+     */
+    private eval;
+    private registerCustomMethodWithContext;
+    /**
+     * Register custom methods with the server context
+     */
+    private registerCustomMethodsWithContext;
+    /**
+     * Setup context with default globals
+     */
+    private setupContext;
+    /**
+     * Setup history file
+     */
+    private setupHistory;
+    /**
+     * Prints the welcome message
+     */
+    private printWelcomeMessage;
+    /**
+     * Prints the help for the custom methods
+     */
+    private printCustomMethodsHelp;
+    /**
+     * Prints the help for the context properties
+     */
+    private printContextHelp;
+    /**
+     * Prints the context to the console
+     */
+    private ls;
+    /**
+     * Notify by writing to the console
+     */
+    notify(message: string): void;
+    /**
+     * Start the REPL session
+     */
+    start(): this;
+    /**
+     * Register a callback to be invoked once the server is ready
+     */
+    ready(callback: (repl: ReplContract) => void): this;
+    /**
+     * Register a custom loader function to be added to the context
+     */
+    addMethod(name: string, handler: Handler, options?: ContextOptions): this;
+}

node_modules/@adonisjs/repl/build/src/Repl/index.js

@@ -0,0 +1,358 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repl = void 0;
+const vm_1 = require("vm");
+const string_width_1 = __importDefault(require("string-width"));
+const colors_1 = require("@poppinss/colors");
+const repl_1 = require("repl");
+const util_1 = require("util");
+const Compiler_1 = require("../Compiler");
+/**
+ * List of node global properties to remove from the
+ * ls inspect
+ */
+const GLOBAL_NODE_PROPERTIES = [
+    'performance',
+    'global',
+    'clearInterval',
+    'clearTimeout',
+    'setInterval',
+    'setTimeout',
+    'queueMicrotask',
+    'clearImmediate',
+    'setImmediate',
+    'exports',
+    '__importDefault',
+];
+/**
+ * Properties injected by the ts-utils
+ * library
+ */
+const TS_UTIL_HELPERS = [
+    '__extends',
+    '__assign',
+    '__rest',
+    '__decorate',
+    '__param',
+    '__metadata',
+    '__awaiter',
+    '__generator',
+    '__exportStar',
+    '__values',
+    '__read',
+    '__spread',
+    '__spreadArrays',
+    '__spreadArray',
+    '__await',
+    '__asyncGenerator',
+    '__asyncDelegator',
+    '__asyncValues',
+    '__makeTemplateObject',
+    '__importStar',
+    '__importDefault',
+    '__classPrivateFieldGet',
+    '__classPrivateFieldSet',
+    '__createBinding',
+];
+const icons = process.platform === 'win32' && !process.env.WT_SESSION
+    ? {
+        tick: '√',
+        pointer: '>',
+    }
+    : {
+        tick: '✔',
+        pointer: '❯',
+    };
+/**
+ * Exposes the API to work the REPL server
+ */
+class Repl {
+    constructor(tsCompiler, historyFilePath) {
+        this.tsCompiler = tsCompiler;
+        this.historyFilePath = historyFilePath;
+        /**
+         * Compiler to compile REPL input
+         */
+        this.compiler = new Compiler_1.Compiler(this.tsCompiler);
+        /**
+         * Length of the longest custom method name. We need to show a
+         * symmetric view of custom methods and their description
+         */
+        this.longestCustomMethodName = 0;
+        /**
+         * Set of registered ready callbacks
+         */
+        this.onReadyCallbacks = [];
+        /**
+         * A set of registered custom methods
+         */
+        this.customMethods = {};
+        /**
+         * Reference to the colors to print colorful messages
+         */
+        this.colors = (0, colors_1.getBest)(false);
+    }
+    /**
+     * Find if the error is recoverable or not
+     */
+    isRecoverableError(error) {
+        if (error.name === 'SyntaxError') {
+            return /^(Unexpected end of input|Unexpected token)/.test(error.message);
+        }
+        return false;
+    }
+    /**
+     * Custom eval method to execute the user code
+     */
+    async eval(cmd, _, filename, callback) {
+        try {
+            let response;
+            const { compiled, awaitPromise } = await this.compiler.compile(cmd, filename);
+            if (awaitPromise) {
+                response = await new vm_1.Script(compiled, { filename }).runInThisContext();
+            }
+            else {
+                response = new vm_1.Script(compiled, { filename }).runInThisContext();
+            }
+            callback(null, response);
+        }
+        catch (error) {
+            if (this.isRecoverableError(error)) {
+                callback(new repl_1.Recoverable(error), null);
+                return;
+            }
+            callback(error, null);
+        }
+    }
+    registerCustomMethodWithContext(name) {
+        const customMethod = this.customMethods[name];
+        if (!customMethod) {
+            return;
+        }
+        /**
+         * Wrap handler
+         */
+        const handler = (...args) => customMethod.handler(this, ...args);
+        /**
+         * Re-define the function name to be more description
+         */
+        Object.defineProperty(handler, 'name', { value: customMethod.handler.name });
+        /**
+         * Register with the context
+         */
+        this.server.context[name] = handler;
+    }
+    /**
+     * Register custom methods with the server context
+     */
+    registerCustomMethodsWithContext() {
+        Object.keys(this.customMethods).forEach((name) => {
+            this.registerCustomMethodWithContext(name);
+        });
+    }
+    /**
+     * Setup context with default globals
+     */
+    setupContext() {
+        /**
+         * Register "clear" method
+         */
+        this.addMethod('clear', function clear(repl, key) {
+            if (!key) {
+                console.log(repl.colors.red('Define a property name to remove from the context'));
+            }
+            else {
+                delete repl.server.context[key];
+            }
+            repl.server.displayPrompt();
+        }, {
+            description: 'Clear a property from the REPL context',
+            usage: `clear ${this.colors.gray('(propertyName)')}`,
+        });
+        /**
+         * Register "p" method
+         */
+        this.addMethod('p', function promisify(_, fn) {
+            return (0, util_1.promisify)(fn);
+        }, {
+            description: 'Promisify a function. Similar to Node.js "util.promisify"',
+            usage: `p ${this.colors.gray('(function)')}`,
+        });
+        /**
+         * Register all custom methods with the context
+         */
+        this.registerCustomMethodsWithContext();
+    }
+    /**
+     * Setup history file
+     */
+    setupHistory() {
+        if (!this.historyFilePath) {
+            return;
+        }
+        this.server.setupHistory(this.historyFilePath, (error) => {
+            if (!error) {
+                return;
+            }
+            console.log(this.colors.red('Unable to write to the history file. Exiting'));
+            console.error(error);
+            process.exit(1);
+        });
+    }
+    /**
+     * Prints the welcome message
+     */
+    printWelcomeMessage() {
+        console.log('');
+        /**
+         * Log about typescript support
+         */
+        if (this.compiler.compilesTs) {
+            console.log(`${this.colors.dim(icons.tick)} ${this.colors.dim('typescript compilation supported')}`);
+        }
+        /**
+         * Log about top level imports
+         */
+        console.log(`${this.colors.dim(icons.tick)} ${this.colors.dim('allows top level imports')}`);
+        console.log('');
+        /**
+         * Log about help command
+         */
+        this.notify('Type ".ls" to a view list of available context methods/properties');
+    }
+    /**
+     * Prints the help for the custom methods
+     */
+    printCustomMethodsHelp() {
+        /**
+         * Print loader methods
+         */
+        console.log('');
+        console.log(this.colors.green('GLOBAL METHODS:'));
+        Object.keys(this.customMethods).forEach((method) => {
+            const { options } = this.customMethods[method];
+            const spaces = new Array(this.longestCustomMethodName - options.width + 2).join(' ');
+            console.log(`${this.colors.yellow(options.usage || method)}${spaces}${this.colors.dim(options.description || '')}`);
+        });
+    }
+    /**
+     * Prints the help for the context properties
+     */
+    printContextHelp() {
+        /**
+         * Print context properties
+         */
+        console.log('');
+        console.log(this.colors.green('CONTEXT PROPERTIES/METHODS:'));
+        const context = Object.keys(this.server?.context).reduce((result, key) => {
+            if (!this.customMethods[key] &&
+                !GLOBAL_NODE_PROPERTIES.includes(key) &&
+                !TS_UTIL_HELPERS.includes(key)) {
+                result[key] = this.server?.context[key];
+            }
+            return result;
+        }, {});
+        console.log((0, util_1.inspect)(context, false, 1, true));
+    }
+    /**
+     * Prints the context to the console
+     */
+    ls() {
+        this.printCustomMethodsHelp();
+        this.printContextHelp();
+        this.server.displayPrompt();
+    }
+    /**
+     * Notify by writing to the console
+     */
+    notify(message) {
+        console.log(this.colors.yellow().italic(message));
+        if (this.server) {
+            this.server.displayPrompt();
+        }
+    }
+    /**
+     * Start the REPL session
+     */
+    start() {
+        this.printWelcomeMessage();
+        this.server = (0, repl_1.start)({
+            prompt: '> ',
+            input: process.stdin,
+            output: process.stdout,
+            terminal: process.stdout.isTTY && !parseInt(process.env.NODE_NO_READLINE, 10),
+            useGlobal: true,
+        });
+        /**
+         * Define ls command
+         */
+        this.server.defineCommand('ls', {
+            help: 'View a list of available context methods/properties',
+            action: this.ls.bind(this),
+        });
+        /**
+         * Setup context
+         */
+        this.setupContext();
+        /**
+         * Setup history
+         */
+        this.setupHistory();
+        /**
+         * Assigning eval function like this has better completion support.
+         */
+        // @ts-ignore
+        this.server['eval'] = this.eval.bind(this);
+        /**
+         * Define exports variable when using Typescript
+         */
+        if (this.compiler.compilesTs) {
+            new vm_1.Script('exports = module.exports', { filename: __dirname }).runInThisContext();
+        }
+        /**
+         * Display prompt
+         */
+        this.server.displayPrompt();
+        /**
+         * Execute onready callbacks
+         */
+        this.onReadyCallbacks.forEach((callback) => callback(this));
+        return this;
+    }
+    /**
+     * Register a callback to be invoked once the server is ready
+     */
+    ready(callback) {
+        this.onReadyCallbacks.push(callback);
+        return this;
+    }
+    /**
+     * Register a custom loader function to be added to the context
+     */
+    addMethod(name, handler, options) {
+        const width = (0, string_width_1.default)(options?.usage || name);
+        if (width > this.longestCustomMethodName) {
+            this.longestCustomMethodName = width;
+        }
+        this.customMethods[name] = { handler, options: Object.assign({ width }, options) };
+        /**
+         * Register method right away when server has been started
+         */
+        if (this.server) {
+            this.registerCustomMethodWithContext(name);
+        }
+        return this;
+    }
+}
+exports.Repl = Repl;

node_modules/@adonisjs/repl/build/standalone.d.ts

@@ -0,0 +1,3 @@
+export { Repl } from './src/Repl';
+export { Compiler } from './src/Compiler';
+export { ImportsParser } from './src/ImportsParser';

node_modules/@adonisjs/repl/build/standalone.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * @adonisjs/repl
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportsParser = exports.Compiler = exports.Repl = void 0;
+var Repl_1 = require("./src/Repl");
+Object.defineProperty(exports, "Repl", { enumerable: true, get: function () { return Repl_1.Repl; } });
+var Compiler_1 = require("./src/Compiler");
+Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return Compiler_1.Compiler; } });
+var ImportsParser_1 = require("./src/ImportsParser");
+Object.defineProperty(exports, "ImportsParser", { enumerable: true, get: function () { return ImportsParser_1.ImportsParser; } });