@modern-js/module-tools 2.0.0-beta.3 → 2.0.0-beta.4

package/compiled/@rollup/plugin-json/types/index.d.ts

@@ -0,0 +1,41 @@
+import { FilterPattern } from '../@rollup/pluginutils';
+import { Plugin } from '../rollup';
+
+export interface RollupJsonOptions {
+  /**
+   * All JSON files will be parsed by default,
+   * but you can also specifically include files
+   */
+  include?: FilterPattern;
+  /**
+   * All JSON files will be parsed by default,
+   * but you can also specifically exclude files
+   */
+  exclude?: FilterPattern;
+  /**
+   * For tree-shaking, properties will be declared as variables, using
+   * either `var` or `const`.
+   * @default false
+   */
+  preferConst?: boolean;
+  /**
+   * Specify indentation for the generated default export
+   * @default '\t'
+   */
+  indent?: string;
+  /**
+   * Ignores indent and generates the smallest code
+   * @default false
+   */
+  compact?: boolean;
+  /**
+   * Generate a named export for every property of the JSON object
+   * @default true
+   */
+  namedExports?: boolean;
+}
+
+/**
+ * Convert .json files to ES6 modules
+ */
+export default function json(options?: RollupJsonOptions): Plugin;

package/compiled/find-up/index.d.ts

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import {Options as LocatePathOptions} from './locate-path';
+
+declare const stop: unique symbol;
+
+declare namespace findUp {
+	interface Options extends LocatePathOptions {}
+
+	type StopSymbol = typeof stop;
+
+	type Match = string | StopSymbol | undefined;
+}
+
+declare const findUp: {
+	sync: {
+		/**
+		Synchronously check if a path exists.
+
+		@param path - Path to the file or directory.
+		@returns Whether the path exists.
+
+		@example
+		```
+		import findUp = require('./find-up');
+
+		console.log(findUp.sync.exists('/Users/sindresorhus/unicorn.png'));
+		//=> true
+		```
+		*/
+		exists: (path: string) => boolean;
+
+		/**
+		Synchronously find a file or directory by walking up parent directories.
+
+		@param name - Name of the file or directory to find. Can be multiple.
+		@returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found.
+		*/
+		(name: string | readonly string[], options?: findUp.Options): string | undefined;
+
+		/**
+		Synchronously find a file or directory by walking up parent directories.
+
+		@param matcher - Called for each directory in the search. Return a path or `findUp.stop` to stop the search.
+		@returns The first path found or `undefined` if none could be found.
+
+		@example
+		```
+		import path = require('path');
+		import findUp = require('./find-up');
+
+		console.log(findUp.sync(directory => {
+			const hasUnicorns = findUp.sync.exists(path.join(directory, 'unicorn.png'));
+			return hasUnicorns && directory;
+		}, {type: 'directory'}));
+		//=> '/Users/sindresorhus'
+		```
+		*/
+		(matcher: (directory: string) => findUp.Match, options?: findUp.Options): string | undefined;
+	};
+
+	/**
+	Check if a path exists.
+
+	@param path - Path to a file or directory.
+	@returns Whether the path exists.
+
+	@example
+	```
+	import findUp = require('./find-up');
+
+	(async () => {
+		console.log(await findUp.exists('/Users/sindresorhus/unicorn.png'));
+		//=> true
+	})();
+	```
+	*/
+	exists: (path: string) => Promise<boolean>;
+
+	/**
+	Return this in a `matcher` function to stop the search and force `findUp` to immediately return `undefined`.
+	*/
+	readonly stop: findUp.StopSymbol;
+
+	/**
+	Find a file or directory by walking up parent directories.
+
+	@param name - Name of the file or directory to find. Can be multiple.
+	@returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found.
+
+	@example
+	```
+	// /
+	// └── Users
+	//     └── sindresorhus
+	//         ├── unicorn.png
+	//         └── foo
+	//             └── bar
+	//                 ├── baz
+	//                 └── example.js
+
+	// example.js
+	import findUp = require('./find-up');
+
+	(async () => {
+		console.log(await findUp('unicorn.png'));
+		//=> '/Users/sindresorhus/unicorn.png'
+
+		console.log(await findUp(['rainbow.png', 'unicorn.png']));
+		//=> '/Users/sindresorhus/unicorn.png'
+	})();
+	```
+	*/
+	(name: string | readonly string[], options?: findUp.Options): Promise<string | undefined>;
+
+	/**
+	Find a file or directory by walking up parent directories.
+
+	@param matcher - Called for each directory in the search. Return a path or `findUp.stop` to stop the search.
+	@returns The first path found or `undefined` if none could be found.
+
+	@example
+	```
+	import path = require('path');
+	import findUp = require('./find-up');
+
+	(async () => {
+		console.log(await findUp(async directory => {
+			const hasUnicorns = await findUp.exists(path.join(directory, 'unicorn.png'));
+			return hasUnicorns && directory;
+		}, {type: 'directory'}));
+		//=> '/Users/sindresorhus'
+	})();
+	```
+	*/
+	(matcher: (directory: string) => (findUp.Match | Promise<findUp.Match>), options?: findUp.Options): Promise<string | undefined>;
+};
+
+export = findUp;

package/compiled/find-up/index.js

@@ -0,0 +1 @@
+(()=>{var e={586:(e,t,r)=>{"use strict";const s=r(17);const n=r(417);const c=r(896);const i=Symbol("findUp.stop");e.exports=async(e,t={})=>{let r=s.resolve(t.cwd||"");const{root:c}=s.parse(r);const o=[].concat(e);const runMatcher=async t=>{if(typeof e!=="function"){return n(o,t)}const r=await e(t.cwd);if(typeof r==="string"){return n([r],t)}return r};while(true){const e=await runMatcher({...t,cwd:r});if(e===i){return}if(e){return s.resolve(r,e)}if(r===c){return}r=s.dirname(r)}};e.exports.sync=(e,t={})=>{let r=s.resolve(t.cwd||"");const{root:c}=s.parse(r);const o=[].concat(e);const runMatcher=t=>{if(typeof e!=="function"){return n.sync(o,t)}const r=e(t.cwd);if(typeof r==="string"){return n.sync([r],t)}return r};while(true){const e=runMatcher({...t,cwd:r});if(e===i){return}if(e){return s.resolve(r,e)}if(r===c){return}r=s.dirname(r)}};e.exports.exists=c;e.exports.sync.exists=c.sync;e.exports.stop=i},417:(e,t,r)=>{"use strict";const s=r(17);const n=r(147);const{promisify:c}=r(837);const i=r(721);const o=c(n.stat);const a=c(n.lstat);const u={directory:"isDirectory",file:"isFile"};function checkType({type:e}){if(e in u){return}throw new Error(`Invalid type specified: ${e}`)}const matchType=(e,t)=>e===undefined||t[u[e]]();e.exports=async(e,t)=>{t={cwd:process.cwd(),type:"file",allowSymlinks:true,...t};checkType(t);const r=t.allowSymlinks?o:a;return i(e,(async e=>{try{const n=await r(s.resolve(t.cwd,e));return matchType(t.type,n)}catch{return false}}),t)};e.exports.sync=(e,t)=>{t={cwd:process.cwd(),allowSymlinks:true,type:"file",...t};checkType(t);const r=t.allowSymlinks?n.statSync:n.lstatSync;for(const n of e){try{const e=r(s.resolve(t.cwd,n));if(matchType(t.type,e)){return n}}catch{}}}},629:(e,t,r)=>{"use strict";const s=r(301);const pLimit=e=>{if(!((Number.isInteger(e)||e===Infinity)&&e>0)){throw new TypeError("Expected `concurrency` to be a number from 1 and up")}const t=new s;let r=0;const next=()=>{r--;if(t.size>0){t.dequeue()()}};const run=async(e,t,...s)=>{r++;const n=(async()=>e(...s))();t(n);try{await n}catch{}next()};const enqueue=(s,n,...c)=>{t.enqueue(run.bind(null,s,n,...c));(async()=>{await Promise.resolve();if(r<e&&t.size>0){t.dequeue()()}})()};const generator=(e,...t)=>new Promise((r=>{enqueue(e,r,...t)}));Object.defineProperties(generator,{activeCount:{get:()=>r},pendingCount:{get:()=>t.size},clearQueue:{value:()=>{t.clear()}}});return generator};e.exports=pLimit},721:(e,t,r)=>{"use strict";const s=r(629);class EndError extends Error{constructor(e){super();this.value=e}}const testElement=async(e,t)=>t(await e);const finder=async e=>{const t=await Promise.all(e);if(t[1]===true){throw new EndError(t[0])}return false};const pLocate=async(e,t,r)=>{r={concurrency:Infinity,preserveOrder:true,...r};const n=s(r.concurrency);const c=[...e].map((e=>[e,n(testElement,e,t)]));const i=s(r.preserveOrder?1:Infinity);try{await Promise.all(c.map((e=>i(finder,e))))}catch(e){if(e instanceof EndError){return e.value}throw e}};e.exports=pLocate},896:(e,t,r)=>{"use strict";const s=r(147);const{promisify:n}=r(837);const c=n(s.access);e.exports=async e=>{try{await c(e);return true}catch(e){return false}};e.exports.sync=e=>{try{s.accessSync(e);return true}catch(e){return false}}},301:e=>{class Node{constructor(e){this.value=e;this.next=undefined}}class Queue{constructor(){this.clear()}enqueue(e){const t=new Node(e);if(this._head){this._tail.next=t;this._tail=t}else{this._head=t;this._tail=t}this._size++}dequeue(){const e=this._head;if(!e){return}this._head=this._head.next;this._size--;return e.value}clear(){this._head=undefined;this._tail=undefined;this._size=0}get size(){return this._size}*[Symbol.iterator](){let e=this._head;while(e){yield e.value;e=e.next}}}e.exports=Queue},147:e=>{"use strict";e.exports=require("fs")},17:e=>{"use strict";e.exports=require("path")},837:e=>{"use strict";e.exports=require("util")}};var t={};function __nccwpck_require__(r){var s=t[r];if(s!==undefined){return s.exports}var n=t[r]={exports:{}};var c=true;try{e[r](n,n.exports,__nccwpck_require__);c=false}finally{if(c)delete t[r]}return n.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var r=__nccwpck_require__(586);module.exports=r})();

package/compiled/find-up/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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/compiled/find-up/locate-path/index.d.ts

@@ -0,0 +1,83 @@
+declare namespace locatePath {
+	interface Options {
+		/**
+		Current working directory.
+
+		@default process.cwd()
+		*/
+		readonly cwd?: string;
+
+		/**
+		Type of path to match.
+
+		@default 'file'
+		*/
+		readonly type?: 'file' | 'directory';
+
+		/**
+		Allow symbolic links to match if they point to the requested path type.
+
+		@default true
+		*/
+		readonly allowSymlinks?: boolean;
+	}
+
+	interface AsyncOptions extends Options {
+		/**
+		Number of concurrently pending promises. Minimum: `1`.
+
+		@default Infinity
+		*/
+		readonly concurrency?: number;
+
+		/**
+		Preserve `paths` order when searching.
+
+		Disable this to improve performance if you don't care about the order.
+
+		@default true
+		*/
+		readonly preserveOrder?: boolean;
+	}
+}
+
+declare const locatePath: {
+	/**
+	Synchronously get the first path that exists on disk of multiple paths.
+
+	@param paths - Paths to check.
+	@returns The first path that exists or `undefined` if none exists.
+	*/
+	sync: (
+		paths: Iterable<string>,
+		options?: locatePath.Options
+	) => string | undefined;
+
+	/**
+	Get the first path that exists on disk of multiple paths.
+
+	@param paths - Paths to check.
+	@returns The first path that exists or `undefined` if none exists.
+
+	@example
+	```
+	import locatePath = require('../locate-path');
+
+	const files = [
+		'unicorn.png',
+		'rainbow.png', // Only this one actually exists on disk
+		'pony.png'
+	];
+
+	(async () => {
+		console(await locatePath(files));
+		//=> 'rainbow'
+	})();
+	```
+	*/
+	(paths: Iterable<string>, options?: locatePath.AsyncOptions): Promise<
+	string | undefined
+	>;
+};
+
+export = locatePath;

package/compiled/find-up/package.json

@@ -0,0 +1 @@
+{"name":"find-up","author":{"name":"Sindre Sorhus","email":"sindresorhus@gmail.com","url":"https://sindresorhus.com"},"version":"5.0.0","funding":"https://github.com/sponsors/sindresorhus","license":"MIT"}

package/compiled/less/index.d.ts

@@ -0,0 +1,282 @@
+// Type definitions for LESS 3.x
+// Project: http://lesscss.org/
+// Definitions by: Tom Hasner <https://github.com/thasner>
+//                 Pranay Prakash <https://github.com/pranaygp>
+//                 Daniel Waxweiler <https://github.com/dwaxweiler>
+//                 Richard Lea <https://github.com/chigix>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace Less {
+    // https://github.com/less/less.js/blob/master/lib/less/import-manager.js#L10
+    interface RootFileInfo {
+        /** whether to adjust URL's to be relative */
+        rewriteUrls?: boolean | undefined;
+        /** full resolved filename of current file */
+        filename: string;
+        relativeUrls: boolean;
+        /** path to append to normal URLs for this node */
+        rootpath: string;
+        /** path to the current file, absolute */
+        currentDirectory: string;
+        /** absolute path to the entry file */
+        entryPath: string;
+        /** filename of the base file */
+        rootFilename: string;
+        /** whether the file should not be output and only output parts that are referenced */
+        reference: boolean;
+    }
+
+    class PluginManager {
+        constructor(less: LessStatic);
+
+        addPreProcessor(preProcessor: PreProcessor, priority?: number): void;
+
+        addFileManager(fileManager: FileManager): void;
+    }
+
+    interface Plugin {
+        install: (less: LessStatic, pluginManager: PluginManager) => void;
+        minVersion?: [number, number, number] | undefined;
+    }
+
+    interface PreProcessor {
+        process: (src: string, extra: PreProcessorExtraInfo) => string;
+    }
+
+    interface PreProcessorExtraInfo {
+        context: {
+            pluginManager: PluginManager;
+        };
+
+        fileInfo: RootFileInfo;
+
+        imports: {
+            [key: string]: any;
+        };
+    }
+
+    interface FileLoadResult {
+        /** Full resolved path to file. */
+        filename: string;
+
+        /** The contents of the file, as a string. */
+        contents: string;
+    }
+
+    interface FileLoadError {
+        /** Error object if an error occurs. */
+        error: unknown;
+    }
+
+    class FileManager extends AbstractFileManager {
+        /**
+         * Returns whether this file manager supports this file for file retrieval
+         * If true is returned, loadFile will then be called with the file.
+         */
+        supports(filename: string, currentDirectory: string, options: LoadFileOptions, environment: Environment): boolean;
+
+        /**
+         * Loads a file asynchronously. Expects a promise that either rejects with an error or fulfills with a FileLoadResult.
+         */
+        loadFile(filename: string, currentDirectory: string, options: LoadFileOptions, environment: Environment): Promise<FileLoadResult>;
+
+        /**
+         * Loads a file synchronously. Expects an immediate return with wither a FileLoadResult or FileLoadError.
+         */
+        loadFileSync(filename: string, currentDirectory: string, options: LoadFileOptions, environment: Environment): FileLoadResult | FileLoadError;
+    }
+
+    class AbstractFileManager {
+        /**
+         * Given the full path to a file, return the path component.
+         */
+        getPath(filename: string): string;
+
+        /**
+         * Append a .less extension if appropriate. Only called if less thinks one could be added.
+         */
+        tryAppendLessExtension(filename: string): string;
+
+        /**
+         * Whether the rootpath should be converted to be absolute.
+         * The browser ovverides this to return true because urls must be absolute.
+         */
+        alwaysMakePathsAbsolute(): boolean;
+
+        /**
+         * Returns whether a path is absolute.
+         */
+        isPathAbsolute(path: string): boolean;
+
+        /**
+         * Joins together 2 paths.
+         */
+        join(basePath: string, laterPath: string): string;
+
+        /**
+         * Returns the difference between 2 paths
+         * E.g. url = a/ baseUrl = a/b/ returns ../
+         * url = a/b/ baseUrl = a/ returns b/
+         */
+        pathDiff(url: string, baseUrl: string): string;
+
+        /**
+         * Returns whether this file manager supports this file for syncronous file retrieval
+         * If true is returned, loadFileSync will then be called with the file.
+         */
+        supportsSync(filename: string, currentDirectory: string, options: LoadFileOptions, environment: Environment): boolean;
+    }
+
+    interface LoadFileOptions {
+        paths?: string[] | undefined;
+        prefixes?: string[] | undefined;
+        ext?: string | undefined;
+        rawBuffer?: any;
+        syncImport?: boolean | undefined;
+    }
+
+    interface Environment {
+        /**
+         * Converts a string to a base 64 string
+         */
+        encodeBase64(str: string): string;
+
+        /**
+         * Lookup the mime-type of a filename
+         */
+        mimeLookup(filename: string): string;
+
+        /**
+         * Look up the charset of a mime type
+         */
+        charsetLookup(mime: string): string;
+
+        /**
+         * Gets a source map generator
+         */
+        getSourceMapGenerator(): any;
+    }
+
+    interface SourceMapOption {
+        sourceMapURL?: string | undefined;
+        sourceMapBasepath?: string | undefined;
+        sourceMapRootpath?: string | undefined;
+        outputSourceFiles?: boolean | undefined;
+        sourceMapFileInline?: boolean | undefined;
+    }
+
+    interface StaticOptions {
+        async: boolean;
+        fileAsync: boolean;
+        modifyVars: { [variable: string]: string };
+    }
+
+    interface ImportManager {
+        contents: { [fileName: string]: string };
+    }
+
+    /**
+     * Reference to:
+     * * https://github.com/less/less.js/blob/master/bin/lessc
+     * * http://lesscss.org/usage/#less-options
+     *
+     * @interface Options
+     */
+    interface Options {
+        sourceMap?: SourceMapOption | undefined;
+        /** Filename of the main file to be passed to less.render() */
+        filename?: string | undefined;
+        /** The locations for less looking for files in @import rules */
+        paths?: string[] | undefined;
+        /** True, if run the less parser and just reports errors without any output. */
+        lint?: boolean | undefined;
+        /** Pre-load global Less.js plugins */
+        plugins?: Plugin[] | undefined;
+        /** @deprecated If true, compress using less built-in compression. */
+        compress?: boolean | undefined;
+        strictImports?: boolean | undefined;
+        /** If true, allow imports from insecure https hosts. */
+        insecure?: boolean | undefined;
+        depends?: boolean | undefined;
+        maxLineLen?: number | undefined;
+        /** @deprecated If false, No color in compiling. */
+        color?: boolean | undefined;
+        /** @deprecated False by default. */
+        ieCompat?: boolean | undefined;
+        /** @deprecated If true, enable evaluation of JavaScript inline in `.less` files. */
+        javascriptEnabled?: boolean | undefined;
+        /** Whether output file information and line numbers in compiled CSS code. */
+        dumpLineNumbers?: "comment" | string | undefined;
+        /** Add a path to every generated import and url in output css files. */
+        rootpath?: string | undefined;
+        /** Math mode options for avoiding symbol conficts on math expressions. */
+        math?: 'always' | 'strict' | 'parens-division' | 'parens' | 'strict-legacy' | number | undefined;
+        /** If true, stops any warnings from being shown. */
+        silent?: boolean | undefined;
+        /** Without this option, Less attempts to guess at the output unit when it does maths. */
+        strictUnits?: boolean | undefined;
+        /** Defines a variable that can be referenced by the file. */
+        globalVars?: {
+          [key: string] : string,
+        } | undefined;
+        /** Puts Var declaration at the end of base file. */
+        modifyVars?: {
+          [key: string] : string,
+        } | undefined;
+        /** Read files synchronously in Node.js */
+        syncImport?: boolean | undefined;
+    }
+
+    interface RenderError {
+        column: number;
+        extract: string[];
+        filename: string;
+        index: number;
+        line: number;
+        message: string;
+        type: string;
+    }
+
+    interface RenderOutput {
+        css: string;
+        map: string;
+        imports: string[];
+    }
+
+    interface RefreshOutput {
+        endTime: Date;
+        startTime: Date;
+        sheets: number;
+        totalMilliseconds: number;
+    }
+}
+
+interface LessStatic {
+    options: Less.StaticOptions;
+
+    importManager?: Less.ImportManager | undefined;
+    sheets: HTMLLinkElement[];
+
+    modifyVars(vars: { [name: string]: string }): Promise<Less.RefreshOutput>;
+
+    refreshStyles(): void;
+
+    render(input: string, callback: (error: Less.RenderError, output: Less.RenderOutput | undefined) => void): void;
+    render(input: string, options: Less.Options, callback: (error: Less.RenderError, output: Less.RenderOutput | undefined) => void): void;
+
+    render(input: string): Promise<Less.RenderOutput>;
+    render(input: string, options: Less.Options): Promise<Less.RenderOutput>;
+
+    refresh(reload?: boolean, modifyVars?: { [variable: string]: string }, clearFileCache?: boolean): Promise<Less.RefreshOutput>;
+
+    version: number[];
+
+    watch(): void;
+
+    FileManager: typeof Less.FileManager;
+    PluginManager: typeof Less.PluginManager;
+}
+
+export = Less;
+
+declare var less: LessStatic;