@makano/rew 1.2.901 → 1.3.0

package/README.md

@@ -12,9 +12,15 @@ Rew
 <a href="https://www.npmjs.com/package/rayous">  <img src="https://img.shields.io/npm/v/@makano/rew?style=for-the-badge&logo=npm&color=b4befe&logoColor=9399b2&labelColor=181825" alt="npm version" /></a>
 </p>
 
-Rew is a simple lightweight coffeescript runtime, made to simply using coffescript and revive it
+Rew is a simple lightweight coffeescript runtime, made to simplify using coffescript and revive it
 in the process.
 
+```coffee
+using namespace std::ns ->
+  define Main ->
+    print 'hello world' |> str
+```
+
 ## Getting Started
 1. Install `rew` globally
   ```bash

package/lib/rew/cli/cli.js

@@ -338,18 +338,45 @@ yargs(hideBin(process.argv))
 			}
 		},
 	)
-
 	.command(
 		'cache <command>',
 		'Manage cache',
+		(yargs) => {
+			yargs
+			.positional('command', {
+				describe: 'Command to clear/list/show',
+				type: 'string',
+			})
+			.example('rew cache list', 'Lists all caches')
+			.example('rew cache clear', 'Clears all caches')
+			.example('rew cache clear all', 'Clears all caches')
+			.example('rew cache clear [id]', 'Clears all caches for id [id]')
+			.example('rew cache show [id]', 'Shows commits downloaded for [id]')
+			.example('rew cache show [id]', 'Shows commits downloaded for [id]')
+			.example('rew cache show [id]/clone', 'Shows the contents for [id]')
+			.example('rew cache show [id]#tag', 'Shows the tag for [id]')
+			.example('rew cache show [id]#commit', 'Shows the current commit for [id]')
+			.example('rew cache show [id]#name', 'Shows the name for [id]')
+			.example('rew cache show [id]/clone/app.yaml', 'Shows the app config for [id]')
+			.example('rew cache show [id]/clone/path/to/file', 'Gives you the path to the file inside [id]')
+			.example('rew cache show [id]/clone/path/to/file', 'Gives you the path to the file inside [id]')
+			.example('rew cache install [id]', 'Installs cache')
+		},
+		async (argv) => {
+			require('./utils').cache(argv.command, ...argv._.slice(1));
+		},
+	)
+	.command(
+		'misc <command>',
+		'Misc functions',
 		(yargs) => {
 			yargs.positional('command', {
-				describe: 'Command to clear/list',
+				describe: 'Misc command name',
 				type: 'string',
 			});
 		},
-		async (argv) => {
-			require('./utils').cache(argv.command)
+		(argv) => {
+			require('./miscUtils')[argv.command](...argv._.slice(1));
 		},
 	)
 	.command(

package/lib/rew/cli/helpers.js

@@ -35,11 +35,36 @@ function getAllPipeInput(){
   });
 }
 
+/**
+ * 
+ * @param {string} string 
+ * @param {Record<string,(replacedString: string, originalString: string) => any>} order 
+ * @returns { { string: string, [key: string]: any } }
+ */
+function hashTags(string, order){
+  const hashes = Object.keys(order);
+  const h = {};
+  let s = string;
+  for(let i of hashes){
+    if(string.includes(`#${i}`)){
+      const str = s.replace(`#${i}`, '');
+      h[i] = order[i](str, string);
+      if(h[i]?.$set) {s = h[i].$set; string = s }
+      else s = str;
+    }
+  }
+  return {
+    string: s,
+    ...h
+  };
+}
+
 module.exports = {
   binpath,
   logspath,
   cachepath,
   localBinPath,
   npm_package_name,
-  getAllPipeInput
+  getAllPipeInput,
+  hashTags
 }

package/lib/rew/cli/miscUtils.js

@@ -0,0 +1,41 @@
+const { findAppInfo } = require("../misc/findAppInfo");
+const { log } = require("./log");
+const colors = require('colors');
+const path = require('path');
+const fs = require('fs');
+const { CONFIG_PATH } = require("../const/config_path");
+
+module.exports = {
+	types(projectPath){
+    if(!projectPath) projectPath = process.cwd();
+    else projectPath = path.resolve(process.cwd(), projectPath);
+    const projectinfo = findAppInfo(projectPath+'/app.yaml');
+    if(!projectinfo){
+      log('Path not a rew app'.red.bold, ':end')
+      return;
+    }
+    let typesToLoad = ['rew'];
+    if(projectinfo.config?.types){
+      typesToLoad = projectinfo.config?.types;
+    }
+    fs.mkdirSync(path.join(projectPath, 'node_modules/@types/rew'), { recursive: true });
+
+
+    typesToLoad.forEach(name => {
+      let filename = name+'.d.ts';
+      if(name == 'rew'){
+				fs.copyFileSync(path.join(__dirname, '../../../runtime.d.ts'), path.join(projectPath, 'node_modules/@types/rew/index.d.ts'));
+        return;
+      }
+      let p = path.resolve(CONFIG_PATH, name, 'app', 'types.d.ts');
+      
+      if(name.indexOf('/') > -1) {
+        const fn = name.split('/').slice(1).join('/')+'.d.ts';
+        p = path.resolve(CONFIG_PATH, name.split('/')[0], 'app', fn);
+        filename = name.split('/')[0]+'-'+path.basename(fn);
+      }
+      if(fs.existsSync(p)) fs.copyFileSync(p, path.join(projectPath, 'node_modules/@types/rew/'+filename));
+    });
+	},
+
+}

package/lib/rew/cli/run.js

@@ -44,6 +44,11 @@ function runFileWithArgv(filePath, options = {}, cargv) {
 	}
 	if (argv.includes('--')) {
 		argv = argv.slice(argv.indexOf('--') + 1, argv.length);
+	} else {
+		const index = argv.find(p => filePath.endsWith(p.replace(/(\.|\.\.)\//, '/')));
+		if(index){
+			argv = argv.slice(argv.indexOf(index) + 1, argv.length);
+		}
 	}
 	runFile(filePath, options, argv);
 }

package/lib/rew/cli/utils.js

@@ -12,9 +12,7 @@ const { to_qrew } = require('../qrew/compile');
 const { findAppInfo } = require('../misc/findAppInfo');
 const { req } = require('../misc/req');
 const { CONFIG_PATH } = require('../const/config_path');
-const { watch } = require('chokidar');
-const { execRewFile, runFileWithArgv } = require('./run');
-const { seededID } = require('../misc/seededid');
+const { runFileWithArgv } = require('./run');
 const loading = require('loading-cli');
 const sleep = require('../functions/sleep');
 const { gen_key } = require('../misc/bin');
@@ -24,7 +22,8 @@ const {
   binpath,
   logspath,
   cachepath,
-  localBinPath
+  localBinPath,
+	hashTags
 } = require('./helpers');
 const { input } = require('../functions/stdout');
 
@@ -94,9 +93,13 @@ module.exports = {
 		const project = {};
 		const create = () => {
 			fs.mkdirSync(projectPath, { recursive: true });
+			const confObj = { manifest: { package: project.package, private: false }, exec: { entry: 'main'+(project.civet ? REW_FILE_TYPE.EXTENSION : '.coffee') }, assets: { icon: 'assets/icon.png', folder: './assets' }, install: { requirements: [] } };
 			const confPath = path.join(projectPath, 'app.yaml');
 			const entryFile = path.join(projectPath, 'main'+(project.civet ? REW_FILE_TYPE.EXTENSION : '.coffee'));
-			fs.writeFileSync(confPath, jsYaml.dump({ manifest: { package: project.package, private: false }, exec: { entry: 'main'+(project.civet ? REW_FILE_TYPE.EXTENSION : '.coffee') }, assets: { icon: 'assets/icon.png', folder: './assets' }, install: { requirements: [] } }));
+			if(project.intellisense) {
+				confObj.types = ['rew'];
+			}
+			fs.writeFileSync(confPath, jsYaml.dump(confObj));
 			fs.writeFileSync(entryFile, `print("Hello World!")`);
 			fs.mkdirSync(path.join(projectPath, 'assets'), { recursive: true });
 			if (project.git) {
@@ -104,8 +107,8 @@ module.exports = {
 				execSync('cd ' + projectPath + ' && git init . && git branch -m main', { stdio: 'ignore' });
 			}
 			if(project.intellisense){
-				fs.mkdirSync(path.join(projectPath, 'node_modules/@types/rew'), { recursive: true });
-				fs.copyFileSync(path.join(__dirname, '../../../runtime.d.ts'), path.join(projectPath, 'node_modules/@types/rew/index.d.ts'));
+				require('./miscUtils')
+				.types(projectPath);
 			}
 			execSync('cd ' + projectPath + ' && npm init -y', { stdio: 'ignore' });
 			if(project.civet){
@@ -382,11 +385,50 @@ module.exports = {
 		processFile(filePath, importsArray);
 		log('󰈔 Compiled'.yellow, (importsArray.length + 1 + '').blue, `file${importsArray.length ? 's' : ''}.`.yellow, ':end');
 	},
-	cache(command){
+	cache(command, file){
+
+		const findGitCommitPath = (p) => {
+			const heads = path.join(p, '.git/refs/heads');
+			if(!fs.existsSync(heads)) return '';
+			const refs = fs.readdirSync(heads);
+			if(!refs.length) return '';
+			return fs.readFileSync(path.join(heads, refs[0]), { encoding: 'utf-8' }).trim();
+		}
+
 		if(command == 'list'){
 			console.log(fs.readdirSync(cachepath).join('\n').trim());
-		} else {
-			fs.readdirSync(cachepath).forEach(file => fs.rmSync(path.join(cachepath, file), { recursive: true }));
+		} else if(command == 'clear'){
+			if(file) fs.rmSync(path.join(cachepath, file), { recursive: true });
+			else if(file == 'all') fs.readdirSync(cachepath).forEach(file => fs.rmSync(path.join(cachepath, file), { recursive: true }));
+		} else if(command == 'install'){
+			if(!file) return process.exit(1);
+			this.installApp(path.join(cachepath, file, 'clone'), {
+				update: true
+			});
+		} else if(command == 'show'){
+			if(!file) return console.log(fs.readdirSync(cachepath).join('\n').trim());
+
+			const hashed = hashTags(file, {
+				tag: (str) => ({ $set: str + '#name#commit' }),
+				commit: (file) => findGitCommitPath(path.join(cachepath, file.replace(/#name/, ''), 'clone')),
+				name: (file) => jsYaml.load(fs.readFileSync(path.join(cachepath, file, 'clone/app.yaml'), { encoding: 'utf-8' }).trim()).manifest.package
+			});
+			file = hashed.string;
+
+			if(hashed.tag){
+				return console.log(hashed.name +':'+ hashed.commit);
+			}
+			if(hashed.commit) return console.log(hashed.commit);
+			if(hashed.name) return console.log(hashed.name);
+
+			const f = path.join(cachepath, file);
+			if(!fs.existsSync(f)) return;
+			if(fs.statSync(f).isDirectory()) console.log(
+				fs.readdirSync(f).join('\n')
+			);
+			else if(file.endsWith('app.yaml')){
+				console.log(fs.readFileSync(f, { encoding: 'utf-8' }).trim());
+			} else console.log(f);
 		}
 	},
 	async cloneGit(gitpath, opts) {

package/lib/rew/const/default.js

@@ -5,7 +5,7 @@ const future = require('../functions/future');
 const sleep = require('../functions/sleep');
 const { match } = require('../functions/match');
 const { map } = require('../functions/map');
-const { typex, typeis, typedef, typei, int, float, num, str, bool } = require('../functions/types');
+const { typex, typeis, typedef, typei, int, float, num, str, bool, typef } = require('../functions/types');
 const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry, getters, setters } = require('../functions/core');
 const { print, input, clear, printf } = require('../functions/stdout');
 const { curl } = require('../functions/curl');
@@ -31,6 +31,7 @@ module.exports = {
 	typei,
 	typeis,
 	typedef,
+	typef,
 
 	int,
 	float,

package/lib/rew/const/stdns.js

@@ -0,0 +1 @@
+module.exports = class STDNS {}

package/lib/rew/const/usage.js

@@ -1,8 +1,9 @@
+const STDNS = require("./stdns");
 
 
 
 const JSX_FRAGMENT_SYMBOL = Symbol('fragment');
-module.exports.USING_DEFAULT = {
+const USING_DEFAULT = module.exports.USING_DEFAULT = {
   JSX: {
     param: (param, fragment) => param ? ({ createElement: param, Fragment: fragment || param(JSX_FRAGMENT_SYMBOL, { isFragment: true }), fragmentSymbol: JSX_FRAGMENT_SYMBOL }) : {},
     use:  (options) => options.jsx = true
@@ -15,7 +16,7 @@ module.exports.USING_DEFAULT = {
   }
 }
 
-module.exports.Usage = class Usage {
+class Usage {
   name = "null";
   trigger = () => {};
   save = true;
@@ -61,6 +62,7 @@ module.exports.Usage = class Usage {
     }
   }
 }
+module.exports.Usage = Usage;
 
 class Namespace extends module.exports.Usage {
   namespace = {};
@@ -84,7 +86,44 @@ class Namespace extends module.exports.Usage {
 module.exports.Namespace = Namespace;
 
 module.exports.namespace = (namespace, cb, parent) => {
+  if(namespace instanceof STDNS) {
+    if(namespace['@cb'] && !cb) {
+      cb = namespace['@cb'];
+      delete namespace['@cb'];
+    }
+  }
   return new Namespace(namespace, cb, parent);
 }
 
+module.exports.usingFunction = (context, runtime) => {
+  return function using(name, ...params) {
+    if(name instanceof Usage.Group){
+      params.unshift(...name.g.slice(1));
+      name = name.g[0];
+    }
+    if(USING_DEFAULT[name]){
+      if(USING_DEFAULT[name].param) {
+        context.__using__[name] = USING_DEFAULT[name].param(...params);
+      }
+    } else if(name instanceof Namespace) {
+      const trigger = name.trigger;
+      const parentContext = name.parent || context;
+      const childContext = {...parentContext, ...name.namespace, trigger};
+      childContext.$self = name.namespace;
+      childContext.$parent = parentContext;
+      const code = `(${trigger.toString()})()`;
+      if(name.onUse) name.onUse();    
+      const r = runtime.exec(code, childContext, code, context.module.filepath);
+      if(name.onAfterUse) name.onAfterUse();
+      return r;
+    } else if(name instanceof Usage) {
+      const v = name.trigger(...params) || true;
+      if(name.save !== false) context.__using__[name.name] = v;
+      return v;
+    } else {
+      context.__using__[name] = params.length ? params.length > 1 ? [...params] : params : true;
+    }
+  }
+}
+
 module.exports.namespace.group = (group, props) => new Namespace.Group(group, props);

package/lib/rew/functions/import.js

@@ -9,6 +9,12 @@ const { execOptions } = require('../const/opt');
 const { REW_FILE_TYPE } = require('../const/ext');
 const { straceLog } = require('../misc/strace');
 
+const _returns = (options, content) => {
+	if(options.useDefaultForPackages){
+		return content?.default ? content : { default: content };
+	} else return content;
+}
+
 const cachedFiles = [];
 module.exports.cleanCache = () => {
 	while(cachedFiles.length) cachedFiles.pop();
@@ -37,7 +43,11 @@ const lookUpInOtherApps = (fullPath) => {
 module.exports.imp = function (runPath, context) {
 	return function (filename, options = {}) {
 		if (!options) options = {};
-		let type = options.type || filename.endsWith('.coffee') ? 'coffee' : REW_FILE_TYPE.TYPE;
+		if(filename == 'std' || filename == '#std') return {};
+		let type = options.type ? options.type : filename.endsWith('.coffee') ? 'coffee' : (
+			filename.endsWith(REW_FILE_TYPE.EXTENSION) ? REW_FILE_TYPE.TYPE :
+			'coffee'
+		);
 		let exports,
 			ispkg = findPackage(filename);
 
@@ -58,10 +68,10 @@ module.exports.imp = function (runPath, context) {
 			else filepath = otherPath;
 		};
 
-		const foundCache = cachedFiles.find((f) => f.filepath == filepath);
+		const foundCache = cachedFiles.find((f) => f.filepath == type+':'+filepath);
 
 		if (!ispkg && foundCache) {
-			exports = foundCache.exports;
+			exports = type === 'coffee' || type === REW_FILE_TYPE.EXTENSION ? foundCache.exports : options.useDefaultForPackages === false ? foundCache.exports.default || foundCache.exports : _returns(options, foundCache.exports);
 		}
 
 		if (!ispkg && !existsSync(filepath) && !foundCache) {
@@ -117,17 +127,17 @@ module.exports.imp = function (runPath, context) {
 			const f = getFile(filepath);
 			if (type == 'yaml') {
 				straceLog('===> FROM_YAML()');
-				exports = importYaml(f.path, f);
+				exports = _returns(options, importYaml(f.path, f));
 			} else if (type == 'json') {
 				straceLog('===>');
 				try {
-					exports = JSON.parse(f.content);
+					exports = _returns(options, JSON.parse(f.content));
 				} catch (e) {
-					exports = {};
+					exports = _returns(options, {});
 				}
 			} else {
 				straceLog('===> FROM_TEXT');
-				exports = f.content;
+				exports = _returns(options, f.content);
 			}
 		}
 
@@ -143,13 +153,13 @@ module.exports.imp = function (runPath, context) {
 		// descriptive code
 		// you put them in comment blocks
 		// and name it something
-		// then you can simple see 
+		// then you can simply see 
 		// which part of a code contains a certain
 		// task. cool right?
 	
 		//**  If is not package, post exec section
 		/**/ if (!ispkg) context.module.imports.push(filepath);
-		/**/ if (!ispkg) cachedFiles.push({ filepath, exports });
+		/**/ if (!ispkg) cachedFiles.push({ filepath: type+':'+filepath, exports });
 		//** 
 
 		//**  Mock imports section	

package/lib/rew/functions/reval.js

@@ -0,0 +1,16 @@
+const { compile } = require("../modules/compiler")
+
+const _compilePart = (code, filepath) => compile(
+  {
+    path: filepath,
+    content: code
+  },
+  {}
+);
+
+module.exports = (filepath) => ({
+  _compilePart: (code) => {
+    return _compilePart(code, filepath);
+  },
+  _call: (fn, ...args) => args.length ? fn.call(...args) : fn()
+})

package/lib/rew/functions/types.js

@@ -14,8 +14,19 @@ function getType(value) {
 	return typeof value === 'object' ? (Array.isArray(value) ? 'array' : typeof value) : typeof value;
 }
 
+class Type{
+	constructor(o){
+		for(let i in o){
+			this[i] = o[i];
+		}
+	}
+}
+
 function typedef(value, strict = false) {
-	return {
+	if(typeof value == "function" && value.type instanceof Type){
+		value = value.type;
+	}
+	return value instanceof Type ? value : new Type({
 		strict,
 		defaultValue: value,
 		class:
@@ -25,25 +36,50 @@ function typedef(value, strict = false) {
 					? value.constructor
 					: _defaultConstructors[getType(value)],
 		type: getType(value),
-		isConstucted: typeof value === 'object' && value !== null && !Array.isArray(value),
+		isConstructed: typeof value === 'object' && value !== null && !Array.isArray(value),
 		isEmpty: typeof value == 'object' ? !Object.keys(value).length : typeof value == 'string' ? value == '' : typeof value !== 'function',
-	};
+	});
+}
+
+function typef(fn, returnType) {
+	if(typeof returnType == "function"){
+		const ref = fn;
+		fn = returnType;
+		returnType = ref;
+	}
+	if (typeof fn !== 'function') {
+		throw new Error('First argument must be a function');
+	}
+	if (typeof returnType == 'function' && returnType.type instanceof Type) returnType = returnType.type;
+	const wrappedFn = function(...args){
+		const result = fn.call(this, ...args);
+		if(!typeis(result, wrappedFn.returnType)){
+			throw new TypeError(`Function ${fn.name || '<anonymous>'} does not return it's own return type.`);
+		}
+		return result;
+	}
+	wrappedFn.returnType = returnType;
+	wrappedFn.type = returnType;
+	return wrappedFn;
+}
+typef.is = function(func, returnType){
+	return typeis(func.returnType.defaultValue, returnType);
 }
 
-function typeis(obj, typeDef) {
+function typeis(obj, typeDef, missingObjects = false) {
 	// Resolve Type
-	if (typeof typeDef == 'function' && typeDef.type) typeDef = typeDef.type;
+	if (typeof typeDef == 'function' && typeDef.type instanceof Type) typeDef = typeDef.type;
 
-	if (typeDef.isConstucted && typeDef.class && !(obj instanceof typeDef.class)) {
-		return false;
+	if (typeDef.isConstructed && typeDef.class && !(obj instanceof typeDef.class)) {
+		return missingObjects ? [false] : false;
 	}
 
 	if (getType(obj) == 'object' && typeDef.type == 'function') {
-		return obj instanceof typeDef.class;
+		return missingObjects ? [obj instanceof typeDef.class] : obj instanceof typeDef.class;
 	}
 
 	if (getType(obj) !== typeDef.type) {
-		return false;
+		return missingObjects ? [false] : false;
 	}
 
 	if (!typeDef.isEmpty) {
@@ -55,14 +91,28 @@ function typeis(obj, typeDef) {
 
 				if (typeof propTypeDef === 'object') {
 					if (!typeis(obj[key], propTypeDef)) {
-						return false;
+						return missingObjects ? [false, {
+							[key]: {
+								type_mismatch: propTypeDef,
+								given: obj[gen_key]
+							}
+						}] : false;
 					}
-				} else if (typeof obj[key] !== propTypeDef) {
-					return false;
+				} else if (typeof obj[key] !== typeof propTypeDef) {
+					return missingObjects ? [false, {
+						[key]: obj[key] ? {
+							type_mismatch: typeof propTypeDef,
+							given: typeof obj[key]
+						} : {
+							not_found: true
+						}
+					}] : false;
 				}
 			}
 			if (typeDef.strict) {
-				if (Object.keys(obj).some((key) => !Object.keys(typeDef.defaultValue).includes(key))) return false;
+				if (Object.keys(obj).some((key) => !Object.keys(typeDef.defaultValue).includes(key))) return missingObjects ?
+					[false, Object.fromEntries(Object.keys(obj).filter((key) => !Object.keys(typeDef.defaultValue).includes(key)).map((key) => [key, { is_extra: true }]))]
+				: false;
 			}
 		} else if (typeDef.type == 'string') {
 			return typeDef.defaultValue == obj;
@@ -71,7 +121,7 @@ function typeis(obj, typeDef) {
 		}
 	}
 
-	return true;
+	return missingObjects ? [true] : true;
 }
 
 function typex(child, parent) {
@@ -112,6 +162,7 @@ module.exports = {
 	typei,
 	typeis,
 	typedef,
+	typef,
 
 	int,
 	float,

package/lib/rew/modules/compiler.js

@@ -86,6 +86,15 @@ function tokenizeCoffeeScript(code) {
       }
       tokens.push({ type: 'IDENTIFIER', value: identifier });
       i--; // Move back one character to recheck
+    } else if (/[a-f0-9.n]/.test(char)) {
+      let num = char;
+      i++;
+      while (i < code.length && /[a-f0-9.n]/.test(code[i])) {
+        num += code[i];
+        i++;
+      }
+      tokens.push({ type: 'NUMBER', value: num });
+      i--; // Move back one character to recheck
     } else {
       // Other characters
       tokens.push({ type: 'OTHER', value: char });
@@ -106,6 +115,13 @@ const ValueIfy = (val) => {
   }
 }
 
+function insertTokenAt(array, index, value) {
+	if (index < 0 || index > array.length) {
+			throw new RangeError('Index out of bounds');
+	}
+	array.splice(index, 0, value);
+}
+
 const gnextToken = (i, n, tokens) => {
 	return tokens[i + n] ? (tokens[i + n].type == 'WHITESPACE' ? gnextToken(i, n + 1, tokens) : { token: tokens[i + n], n, ti: i + n }) : null;
 };
@@ -153,7 +169,7 @@ function declareAlias(aliases, token) {
 			aliasValue = (token, tokens, code, hooks, index, setIndex) => {
 				const nextToken = tokens[index+1]
 				let nextToken2 = gnextToken(index, 3, tokens);
-				if (nextToken.value == '(' || tokens[index+2]?.value == '(') {
+				if (nextToken?.value == '(' || tokens[index+2]?.value == '(') {
 					let params = '';
 					index += 2;
 					let openBrackets = 1;
@@ -172,7 +188,7 @@ function declareAlias(aliases, token) {
 					let nextToken = gnextToken(index, offset+1, tokens);
 					const args = nextToken.token.value;
 					setIndex(ti + offset);
-					return `${nextToken2.value} = ${token.value} ${args && args !== '(' ? `${args},` : ''} ${params.trim()}, ${args == '(' ? args : ''}`;
+					return `${nextToken2.value} = ${token.value} ${args && args !== '(' && args !== '{' && args !== '[' && args !== '-' && args !== '=' ? `${args},` : ''} ${params.trim() ? params.trim() + ', ' : ''}${args == '(' || args == '[' || args == '{' || args == '=' || args == '-' ? args : ''}`.replace(/,(| )$/, '');
 				} else if(nextToken?.value == ' ' && (isDecOnly || nextToken2?.token.value == '=' || nextToken2?.token.value == ':')){
 					nextToken.value = '';
 					if(isDecOnly){
@@ -204,7 +220,21 @@ function declareAlias(aliases, token) {
   }
 }
 
-
+const stdTypes = (isPublic) => {
+	let r = '';
+	const dec = (name, fn) => {
+		r += `#declare${isPublic?'*':''} key "=${name}" = ${fn || name};\n`
+	}
+	dec('int');
+	dec('str');
+	dec('float');
+	dec('num');
+	dec('bool');
+	dec('typedef');
+	dec('typef');
+	dec('struct');
+	return r;
+};
 const includeFile = (includeContent, options) => {
 	straceLog('INCLUDE()', includeContent);
 	const dontInclude = includeContent.startsWith('*');
@@ -212,21 +242,30 @@ const includeFile = (includeContent, options) => {
 		includeContent = includeContent.slice(1);
 		straceLog('==> IGNORING OUTPUT', includeContent);
 	};
-	let filename = options.filename ? path.resolve(path.dirname(options.filename), includeContent) : includeContent;
-	const _inc = (filename) => '\n'+ compileRewStuff(readFileSync(filename).toString(), {
-		...options,
-		filename,
-		included: true
-	})+'\n';
+	const fp = path.resolve(path.dirname(options.filename || ''), includeContent);
+	let packageName = options.filename ? (existsSync(fp) ? fp : includeContent) : includeContent;
+	const file = packageName.startsWith('./') || packageName.startsWith('../');
+	if(!(file) && packageName.match('/')) packageName = packageName.split('/').pop();
+	if(file) packageName = path.extname(packageName) ? packageName.replace(path.extname(packageName), '.h.coffee') : packageName;
+	if(file && !packageName.endsWith('.h.coffee')) packageName += '.h.coffee';
+	if(includeContent == 'std') packageName = 'std';
+
+	const _inc = (filename, c) => {
+		options.included = true;
+		options.filename = filename;
+		return '\n'+ compileRewStuff(c ? filename : readFileSync(filename).toString(), options)+'\n'
+	};
 	let r = '';
-	if (existsSync(filename)) {
-		straceLog('==> INCLUDE FILE', filename);
-		r = _inc(filename);
+	if(packageName == 'std'){
+		r = _inc(stdTypes(dontInclude), true);
+	} else if (existsSync(packageName)) {
+		straceLog('==> INCLUDE FILE', packageName);
+		r = _inc(packageName);
 	} else {
 		const packageName = includeContent.match('/') ? includeContent.split('/')[0] : includeContent;
 		const headerFile = includeContent.match('/') ? includeContent.replace(packageName+'/', '') : 'main.h.coffee';
 		const pathname = path.join(CONFIG_PATH, packageName, 'app', headerFile);
-		straceLog('==> INCLUDE PACKAGE', filename);
+		straceLog('==> INCLUDE PACKAGE', packageName);
 		if(existsSync(pathname)) r = _inc(pathname);
 	}
 	if(dontInclude){
@@ -245,16 +284,22 @@ function useImp(token, options){
 		const value = token.value.slice(1, -1);
 		let packageName = value.slice(1);
 		token.value = dem+packageName+dem;
-		const file = packageName.startsWith('./') || packageName.startsWith('../');
-		if(!(file) && packageName.match('/')) packageName = packageName.split('/').pop();
-		if(file) packageName = path.extname(packageName) ? packageName.replace(path.extname(packageName), '.h.coffee') : packageName;
-		if(file && !packageName.endsWith('.h.coffee')) packageName += '.h.coffee';
 		straceLog('IMP() with HEADER for', packageName);
-		return includeFile(packageName, options); 
+		return includeFile(packageName !== 'std' ? packageName : '*'+packageName, options); 
 	}
 	return '';
 }
 
+function updateAliases(aliases, o = execOptions._syntaxAliases){
+	for(let h in o){
+		for(let i in o[h]){
+			if(!aliases[h]) aliases[h] = {};
+			aliases[h][i] = o[h][i]
+		}
+	}
+	return aliases;
+}
+
 function compileRewStuff(content, options) {
 	straceLog('TOKENIZE() for CURRENTFILE');
 	const tokens = tokenizeCoffeeScript(content);
@@ -292,6 +337,19 @@ function compileRewStuff(content, options) {
 			}
     }
 
+		if (token.type === "COMMENT" && token.value.startsWith('#alias')) {
+			let value = '#declare';
+			if(token.value.match(/^#alias\*/)) value += '*';
+			let subs;
+			subs = token.value.replace(/^#alias/, '');
+			if(token.value.endsWith('*')) subs.split('*')[1];
+			
+			value += ' key';
+			value += ' ' + subs.replace(/([\S]+)\s*=\s*([\S]+)/, '"$1" = $2').trim();
+			value += ';';
+			declareAlias(aliases, {...token, value});
+    }
+
 		if (token.type === "COMMENT" && token.value.startsWith('#declare')) {
       if (token.value.includes(';')) {
         declareAlias(aliases, token);
@@ -309,28 +367,6 @@ function compileRewStuff(content, options) {
 			}
 		}
 		
-		if (token.type === 'IDENTIFIER' && token.value === 'imp') {
-			straceLog('IMP() Detected');
-			let { token: t1 } = gnextToken(i, 1, tokens) || {};
-			let { token: t2 } = gnextToken(i, 2, tokens) || {};
-			let r = '';
-
-			if(t1.value == '('){
-				if(t2.type == 'STRING'){
-					r = useImp(t2, options);
-				}
-			} else if(t1.type == 'STRING'){
-				r = useImp(t1, options);
-			}
-
-			if(r) {
-				aliases = {
-					...aliases,
-					...execOptions._syntaxAliases
-				}
-			}
-		}
-
 		if (token.type === 'COMMENT' && token.value.slice(1).trim().startsWith('@jsx')) {
 			options.jsx = true;
 			straceLog('JSX() ENABLE WITH COMMENTS');
@@ -342,7 +378,7 @@ function compileRewStuff(content, options) {
 		
     if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@cls') {
 			options.cls = true;
-			straceLog('CLITOKENIZATION() ENABLE');
+			straceLog('CLI_SYNTAX() ENABLE');
 			straceLog('===> HIGHLY EXPERIMENTAL FEATURE DETECTED');
 		}
 
@@ -365,6 +401,25 @@ function compileRewStuff(content, options) {
 			token.value = 'pub';
 			straceLog('EXPORT() => TRANSLATING TO pub');
 		}
+		
+		if (token.type === 'IDENTIFIER' && token.value === 'package' && nextToken.type == 'STRING') {
+			token.value = 'appPackage';
+			straceLog('APP_PACKAGE_CHANGE()');
+		}
+
+		if (
+			token.type === 'OTHER' && token.value === '-' &&
+			nextToken.type == 'IDENTIFIER' && nextToken.value === 'wait'
+		) {
+			const { token: nextNextToken } = gnextToken(i, 2, tokens) || {};
+			if(nextNextToken?.type == 'IDENTIFIER'){
+				token.value = '';
+				hooks.push({
+					index: i + 3,
+					value: ','
+				});
+			}
+		}
 
 		if (token.type === 'IDENTIFIER' && token.value === 'using' && !options.disableUse) {
 			straceLog('USING()');
@@ -380,15 +435,30 @@ function compileRewStuff(content, options) {
 			} else straceLog('==> UNKNOWN');
 		}
 
+		if (token.type === 'IDENTIFIER' && token.value === 'as' && !options.keepImports) {
+			const isFrom = gnextToken(i, 3, tokens);
+			const isInImport = tokens[i-2];
+			if(isFrom?.token.value == 'from' && isInImport?.value !== '*'){
+				insertTokenAt(tokens, i, { type: 'WHITESPACE', value: ' ' });
+				insertTokenAt(tokens, i, { type: 'OTHER', value: '*' });
+				insertTokenAt(tokens, i, { type: 'WHITESPACE', value: ' ' });
+				insertTokenAt(tokens, i, { type: 'IDENTIFIER', value: 'import' });
+				i -= 1;
+				continue;
+			}
+		}
+
 		if (token.type === 'IDENTIFIER' && token.value === 'import' && !options.keepImports) {
 			// console.log(nextToken.type);
 			straceLog('IMPORT()');
-			straceLog('==> WARN: SLOWS DOWN TOKENIZATION');
+			straceLog('==> WARN: SLOWS DOWN COMPILATION');
 			let ind = i + n + 2;
+			let isAs = false;
 
 			let defaultName;
 			if (nextToken.type === 'STRING') {
 				straceLog('==> SIMPLE');
+				if(useImp(nextToken, options)) updateAliases(aliases);
 				result += `inc ${nextToken.value}`;
 				i += n;
 			} else if (nextToken.value === '{') {
@@ -405,18 +475,21 @@ function compileRewStuff(content, options) {
 					
 					straceLog('==>', exports, 'from', nameToken.value);
 
+					if(useImp(nameToken, options)) updateAliases(aliases);
 					result += `{ ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
 					i = nameToken.ti;
 				}
 			} else if (nextToken.value === '*') {
 				const asToken = fnextToken(ind, tokens, 'IDENTIFIER', 'as');
-				const nameToken = fnextToken(asToken.ri, tokens, 'STRING');
 				if (asToken) {
+					const nameToken = fnextToken(asToken.ti, tokens, 'STRING');
 					const nextToken = fnextToken(asToken.ti + 1, tokens, 'IDENTIFIER');
 					defaultName = nextToken.value;
 					straceLog('==>', defaultName, 'from', nameToken.value);
+					if(useImp(nameToken, options)) updateAliases(aliases);
 					result += `${defaultName} ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken.value}`;
 					i = ind + 6;
+					isAs = true;
 				}
 			} else if (nextToken) {
 				const nameToken = fnextToken(ind, tokens, 'STRING');
@@ -433,10 +506,12 @@ function compileRewStuff(content, options) {
 							.filter((t, i, arr) => !arr[i+1]?.match(':') && !arr[i-1]?.match(':'))
 							.join(', ');
 						straceLog('==>', defaultName, 'and', exports, 'from', nameToken.value);
+						if(useImp(nameToken, options)) updateAliases(aliases);
 						result += `{ default: ${defaultName}, ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 						i = closingBraceToken.ti + 4;
 					}
 				} else {
+					if(useImp(nameToken || {}, options)) updateAliases(aliases);
 					result += `{ default: ${defaultName} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 					i = ind + 2;
 				}
@@ -451,19 +526,38 @@ function compileRewStuff(content, options) {
 				if(assertionToken.token.type == 'OTHER' && assertionToken.token.value == '{'){
 					hooks.push({
 						index: assertionToken.token.ti,
-						value: ' useDefaultForPackages: true, '
+						value: ' useDefaultForPackages: '+(isAs?'false':'true')+', '
 					})
 				} else {
-					result += 'useDefaultForPackages: true, '
+					result += 'useDefaultForPackages: '+(isAs?'false':'true')+', '
 				}
 				i += 3;
 			} else {
-				result += ", { useDefaultForPackages: true }"
+				result += ", { useDefaultForPackages: "+(isAs?'false':'true')+" }"
 			}
 
 			continue;
 		}
 
+		if (token.type === 'IDENTIFIER' && (token.value === 'imp' || token.value === 'inc')) {
+			straceLog('IMP() Detected');
+			let { token: t1 } = gnextToken(i, 1, tokens) || {};
+			let { token: t2 } = gnextToken(i, 2, tokens) || {};
+			let r = '';
+
+			if(t1?.value == '('){
+				if(t2?.type == 'STRING'){
+					r = useImp(t2, options);
+				}
+			} else if(t1?.type == 'STRING'){
+				r = useImp(t1, options);
+			}
+
+			if(r) {
+				updateAliases(aliases);
+			}
+		}
+
 		if (
 			token.type === 'IDENTIFIER' &&
 			token.value === 'pub' &&
@@ -516,16 +610,18 @@ function compileRewStuff(content, options) {
 		
 		if (token.type === "COMMENT" && token.value.startsWith('#include')) {
 			const includeContent = token.value.split(' ')[1].trim() || '';
-			const r = includeFile(includeContent, options);
+			const _o = {...options};
+			const r = includeFile(includeContent, _o);
 			if(r){
 				result += r == 'intentional-nothing' ? '' : r;
-				aliases = {
-					...aliases,
-					...execOptions._syntaxAliases
-				}
+				updateAliases(aliases, _o.aliases);
 			}
     }
 	}
+
+	if(options.included){
+		options.aliases = aliases;
+	}
 	// console.log(aliases);
 	// console.log(result);
 	return result;
@@ -540,6 +636,8 @@ const compileCivetStuff = (file, options) => {
 	straceLog('OPTION_PREPARE() for CURRENTFILE as', preCompileOptions);
 	const prepared = compileRewStuff(file.content, preCompileOptions);
 
+	// console.log(prepared);
+
 	const compileOptions = {
 		...preCompileOptions,
 		bare: true,

package/lib/rew/modules/context.js

@@ -8,10 +8,11 @@ const pathLib = require("../functions/path");
 const path = require("path");
 const execLib = require("../functions/exec");
 const { findAppInfo } = require("../misc/findAppInfo");
-const { USING_DEFAULT, Usage, Namespace } = require("../const/usage");
+const { Usage, usingFunction } = require("../const/usage");
 const runtime = require("./runtime");
-const { permission } = require("process");
 const { straceLog } = require("../misc/strace");
+const reval = require("../functions/reval");
+const STDNS = require("../const/stdns");
 
 let mainFile = "";
 const isMainFile = (filepath) => filepath == mainFile;
@@ -37,6 +38,7 @@ module.exports.prepareContext = function (
     },
     app: findAppInfo(filepath),
     ...fsLib(filepath),
+    ...reval(filepath),
     __using__: {}
   };
   if (options.useContext) {
@@ -45,14 +47,44 @@ module.exports.prepareContext = function (
       ...context,
     };
   } else {
+    const std = {...defaultContext};
     context = {
       ...context,
-      ...defaultContext,
+      ...std,
       ...pathLib(filepath),
       ...execLib(filepath),
       ...custom_context,
       Usage
     };
+    std.prototype = { ns: (cb) => {
+      return new (class extends STDNS {
+        constructor(){
+          super();
+          for(let i in std){
+            this[i] = std[i];
+          }
+          this.define = std.prototype.define;
+          this.Main = std.prototype.Main;
+          this['@cb'] = cb;
+        }
+      });
+    }, define: (name, object) => {
+      if(Array.isArray(name) && name.length == 2 && typeof name[0] == 'string'){
+        object = name[1];
+        name = name[0];
+      }
+      if(!context.module.exports) context.module.exports = {};
+      context.module.exports[name] = object;
+      context[name] = object;
+    }, Main: (cb) => (['main', cb?.main ?? cb]), attach: (object) => {
+      for(let i in object){
+        if(!context[i]) context[i] = object[i];
+      }
+    } }
+    Object.defineProperty(std.prototype, 'void', {
+      get: () => void 0
+    })
+    context.std = std;
   }
   if (!context.process)
     context.process = {
@@ -68,10 +100,19 @@ module.exports.prepareContext = function (
       abort: () => process.abort(),
       kill: () => process.kill(),
       exit: (code) => process.exit(code),
+      chdir: (dir) => process.chdir(dir),
+      disconnect: () => process.disconnect(),
       arch: process.arch,
       pid: process.pid,
       platform: process.platform,
-      permission: process.permission
+      channel: process.channel,
+      uptime: () => process.uptime(),
+      nextTick: (callback, ...args) => process.nextTick(callback, ...args),
+      permission: process.permission,
+      transmit: {
+        send: (...data) => process.send(...data),
+        recieve: (cb) => process.on('message', cb)
+      }
     };
 
   context.global = context;
@@ -118,34 +159,7 @@ module.exports.prepareContext = function (
   context.pub = pubFunction(context);
   context.exports = exportsFunction(context);
 
-  context.using = (name, ...params) => {
-    if(name instanceof Usage.Group){
-      params.unshift(...name.g.slice(1));
-      name = name.g[0];
-    }
-    if(USING_DEFAULT[name]){
-      if(USING_DEFAULT[name].param) {
-        context.__using__[name] = USING_DEFAULT[name].param(...params);
-      }
-    } else if(name instanceof Namespace) {
-      const trigger = name.trigger;
-      const parentContext = name.parent || context;
-      const childContext = {...parentContext, ...name.namespace, trigger};
-      childContext.currentNamespace = name.namespace;
-      childContext.parentNamespace = parentContext;
-      const code = `(${trigger.toString()})()`;
-      if(name.onUse) name.onUse();    
-      const r = runtime.exec(code, childContext, code, context.module.filepath);
-      if(name.onAfterUse) name.onAfterUse();
-      return r;
-    } else if(name instanceof Usage) {
-      const v = name.trigger(...params) || true;
-      if(name.save !== false) context.__using__[name.name] = v;
-      return v;
-    } else {
-      context.__using__[name] = params.length ? params.length > 1 ? [...params] : params : true;
-    }
-  };
+  context.using = usingFunction(context, runtime);
 
   if(context.app?.config?.exec?.['auto import']){
     const autoipath = path.join(context.app.path, context.app.config?.exec?.['auto import']);

package/lib/rew/modules/runtime.js

@@ -36,7 +36,8 @@ module.exports.runPath = function runPath(filepath, options = {}, custom_context
 	
 		if(context.app){
 			const p = path.join(CONFIG_PATH, context.app.config.manifest.package, 'app');
-			if(existsSync(p) && context.app.path !== p){
+			const p2 = path.join(CONFIG_PATH, context.app.config.manifest.package, 'app/.allow');
+			if(existsSync(p) && context.app.path !== p && !existsSync(p2)){
 				console.log("App with the same package name has been installed. Conflicts happened. \nTo fix this, change your app's package name or remove the app making the conflict.");
 				return {
 					context: { module: { exports: null } },
@@ -46,11 +47,21 @@ module.exports.runPath = function runPath(filepath, options = {}, custom_context
 		}
 	
 		compiled_code = preScript+'\n'+compiled_code;
-	
-		return {
-			context,
-			returns: exec(compiled_code, context, file.content),
-		};
+
+		let execd = exec(compiled_code, context, file.content);
+
+		if(context.module.main && (context.module.exports?.main || (typeof context.module.exports == "function" && context.module.exports.name == 'main'))){
+			const mainFn = context.module.exports.main ?? context.module.exports;
+			return {
+				context,
+				returns: mainFn.call(context, context.process.argv)
+			}
+		} else {
+			return {
+				context,
+				returns: execd,
+			};
+		}
 	}
 
 	if(options.async){

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.2.901",
+  "version": "1.3.0",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {

package/runtime.d.ts

@@ -1006,4 +1006,24 @@ declare namespace Rew {
     group(...group: any[]): { g: T, with: (props: any) => { g: T, [key: string]: any }, [key: string]: any }
   }
 
+  declare const std = {
+    curl: curl,
+    int: int,
+    str: str,
+    bool: bool,
+    float: float,
+    num: num,
+    typeis: typeis,
+    typex: typex,
+    typei: typei,
+
+    prototype: {
+      void: () => void 0,
+      Main: () => [string, () => any],
+      define: (name: string, object: any) => any,
+      attach: (object: any) => any,
+      ns: () => any
+    }
+  }
+
 // }