@ibyar/expressions 0.5.2 → 0.5.62

package/api/expression.d.ts

@@ -1,5 +1,6 @@
-import type { Scope, ScopeType } from '../scope/scope.js';
+import type { Scope, ScopeContext } from '../scope/scope.js';
 import type { Stack } from '../scope/stack.js';
+import { TypeOf } from './utils.js';
 export declare type NodeType = {
     type: string;
 };
@@ -20,35 +21,175 @@ export declare type ExpressionEventMap = {
     [key: string]: ExpressionEventMap;
 };
 export interface ExpressionNode {
-    shareVariables(scopeList: Scope<any>[]): void;
+    /**
+     * pass scope list from outer function to inner function,
+     *
+     * all other end point expression should do nothing,
+     *  if this function executed.
+     *
+     * @param scopeList all outer function scopes given to the inner function,
+     * this solution ignore the fact that some inner function has no need to
+     * get shared variables, as its implementation never say that
+     * ```js
+     * function f(d) {
+     * 		function g() {
+     * 			const a = ({ d }) => d;
+     * 			return a;
+     * 		}
+     * 		return [d, g];
+     * }
+     * ```
+     */
+    shareVariables(scopeList: Scope<ScopeContext>[]): void;
+    /**
+     * assign the value to this expression in stack.
+     *
+     * most ExpressionNode will not implement this method, and will throw an exception.
+     * @param stack
+     * @param value
+     */
     set(stack: Stack, value: any): any;
+    /**
+     * execute/get the code for this expression and return the result value.
+     * @param stack
+     * @param thisContext
+     */
     get(stack: Stack, thisContext?: any): any;
+    /**
+     * get all dependencies form an expression node
+     *
+     * tha return from this method, is represent an answer for what identifiers this expression depends-on.
+     *
+     *
+     * ex:
+     * ```js
+     * x + y;
+     * ```
+     *
+     * - for `+` operator :	the answer should be `lhs` and `rhs`,
+     * - for `x` identifier:	the answer should be node `x`,
+     * - for `y` identifier:	the answer should be node `y`.
+     *
+     * so, the return from `+` will be `[ node 'x', node 'y']`
+     *
+     * and:
+     * - `x.y.z * a` ==> `[ member node `x.y.z`, identifier 'a']`
+     * @param computed
+     */
     dependency(computed?: true): ExpressionNode[];
+    /**
+     * ex:
+     * ```js
+     * x + y;
+     * ```
+     *
+     * - for `+` operator :	the answer should be `lhs` and `rhs`,
+     * - for `x` identifier:	the answer should be node `x`,
+     * - for `y` identifier:	the answer should be node `y`.
+     *
+     * so, the return from `+` will be `['x', 'y']`
+     *
+     * and:
+     * - `x.y.z` ==> `['x', 'y', 'z']`
+     * - `x[y].z` ==> ['x', ]
+     * @param computed required for member and chaining operators
+     */
     dependencyPath(computed?: true): ExpressionEventPath[];
+    /**
+     * get all the events form this expression
+     *
+     * tha return from this method, is represent an answer for what is this expression depends-on as identifier name
+     *
+     * ex:
+     * ```js
+     * x + y;
+     * ```
+     *
+     * - for `+` operator :	the answer should be `lhs` and `rhs`,
+     * - for `x` identifier: the answer should be `x`
+     * - for `y` identifier: the answer should be `y`
+     * the final output will be
+     *
+     * so, the return from `+` will be `{ x: undefined, y: undefined }`
+     *
+     * and:
+     * - `x.y.z * a` ==> `{ x: { y: { z: undefined }, a: undefined } }`
+     * - `x.y.z > x.y.h.g` ==> `{ x: { y: { z: undefined, h: { g: undefined} } } }`
+     * - `x[Symbol.toStringTag] + 'Class' + classType + array[3]` ==> `{ x: { 'Symbol.toStringTag': undefined }, classType: undefined,  array: { 3: undefined }  }`
+     * - `'name'` ==> {}
+     * - ```js
+     * user[firstName + `son of ${fatherName}`]
+     * ``` ==> `{ user: { 'firstName:fatherName': undefined }, firstName: undefined, fatherName: undefined }`
+     * @param parent
+     */
     events(): ExpressionEventMap;
+    /**
+     * re-write this expression as a javascript source
+     */
     toString(): string;
+    /**
+     * used to map this object to represent an [ESTree](https://github.com/estree/estree) json object
+     * @param key
+     */
     toJSON(): NodeJsonType;
-    getClass(): NodeExpressionClass<ExpressionNode>;
-}
-interface TypeOf<T> {
-    new (...params: any[]): T;
+    /**
+     * just a helper method to force class that implement this interface to
+     * have a static method `fromJSON` to help reconstruct this ExpressionNode
+     * from an [ESTree](https://github.com/estree/estree) json object,
+     * with all necessary implementation to execute the code
+     */
+    getClass(): ExpressionNodConstructor<ExpressionNode>;
 }
 export declare type NodeDeserializer<N = ExpressionNode> = (node: N) => N;
 export declare type VisitNodeType = (expression: ExpressionNode) => void;
-export declare type VisitNodeListType = (expressions: ExpressionNode[]) => void;
-export interface NodeExpressionClass<N extends ExpressionNode> extends TypeOf<N> {
-    fromJSON(node: N, deserializer: NodeDeserializer): N;
-    visit?(node: N, visitNode: VisitNodeType, visitNodeList: VisitNodeListType): void;
-}
-export interface NodeExpressionWithType<N extends ExpressionNode> extends NodeExpressionClass<N> {
+/**
+ * this is how to:
+ * describe a class with it's static functions and properties
+ * in the interface add getClass method
+ */
+export interface ExpressionNodConstructor<N extends ExpressionNode> extends TypeOf<N> {
+    /**
+     * the type of an expression
+     */
     type: string;
+    /**
+     * build expression node from [ESTree](https://github.com/estree/estree) json object
+     * @param node
+     * @param deserializer
+     */
+    fromJSON(node: N, deserializer: NodeDeserializer): N;
+    /**
+     * visit nodes inside expression
+     * @param expression
+     * @param callback
+     */
+    visit?(node: N, visitNode: Object): void;
 }
-export interface CanDeclareExpression extends ExpressionNode {
-    declareVariable(stack: Stack, scopeType: ScopeType, propertyValue?: any): any;
+export interface DeclarationExpression extends ExpressionNode {
+    /**
+     * declare variable in the current local scope (block),
+     * or closest function scope (global) scop,
+     * the propertyName will be calculated at runtime
+     * @param stack the stack which an identifier will be declared
+     * @param propertyValue the initial value of identifier
+     * @param scope which scop to declare this identifier
+     */
+    declareVariable(stack: Stack, propertyValue?: any): any;
+    /**
+     * get the variable declaration name
+     */
+    getDeclarationName?(): string;
 }
+/**
+ * An interface meant to be implemented by MemberExpression,
+ * Identifier and ChainExpression and all Literal expressions
+ */
 export interface CanFindScope {
-    findScope<T extends object>(stack: Stack): Scope<T>;
-    findScope<T extends object>(stack: Stack, scope: Scope<any>): Scope<T>;
-    findScope<T extends object>(stack: Stack, scope?: Scope<any>): Scope<T> | undefined;
+    /**
+     * try to search for scope of this expression
+     * @param stack
+     */
+    findScope<T extends ScopeContext>(stack: Stack): Scope<T>;
+    findScope<T extends ScopeContext>(stack: Stack, scope: Scope<ScopeContext>): Scope<T>;
+    findScope<T extends ScopeContext>(stack: Stack, scope?: Scope<ScopeContext>): Scope<T> | undefined;
 }
-export {};

package/api/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../../src/expressions/api/expression.ts"],"names":[],"mappings":"","sourcesContent":["import type { Scope, ScopeType } from '../scope/scope.js';\nimport type { Stack } from '../scope/stack.js';\n\nexport type NodeType = { type: string };\nexport type NodeJsonType = { [key: string]: any } & NodeType;\n\nexport type ExpressionEventPathDotNotation = { computed: false, path: string };\nexport type ExpressionEventPathBracketNotation = { computed: true, path: string, computedPath: ExpressionEventPath[][] };\nexport type ExpressionEventPath = ExpressionEventPathDotNotation | ExpressionEventPathBracketNotation;\nexport type ExpressionEventMap = { [key: string]: ExpressionEventMap };\n\nexport interface ExpressionNode {\n\n\t/**\n\t * pass scope list from outer function to inner function,\n\t * \n\t * all other end point expression should do nothing,\n\t *  if this function executed.\n\t * \n\t * @param scopeList all outer function scopes given to the inner function,\n\t * this solution ignore the fact that some inner function has no need to\n\t * get shared variables, as its implementation never say that\n\t * ```js\n\t * function f(d) {\n\t * \t\tfunction g() {\n\t * \t\t\tconst a = ({ d }) => d;\n\t * \t\t\treturn a;\n\t * \t\t}\n\t * \t\treturn [d, g];\n\t * }\n\t * ```\n\t */\n\tshareVariables(scopeList: Scope<any>[]): void;\n\n\t/**\n\t * assign the value to this expression in stack.\n\t * \n\t * most ExpressionNode will not implement this method, and will throw an exception.\n\t * @param stack \n\t * @param value \n\t */\n\tset(stack: Stack, value: any): any;\n\n\t/**\n\t * execute/get the code for this expression and return the result value.\n\t * @param stack \n\t * @param thisContext \n\t */\n\tget(stack: Stack, thisContext?: any): any;\n\n\t/**\n\t * get all dependencies form an expression node\n\t *\n\t * tha return from this method, is represent an answer for what identifiers this expression depends-on.\n\t * \n\t *\n\t * ex:\n\t * ```js\n\t * x + y;\n\t * ```\n\t *\n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier:\tthe answer should be node `x`,\n\t * - for `y` identifier:\tthe answer should be node `y`.\n\t *\n\t * so, the return from `+` will be `[ node 'x', node 'y']`\n\t *\n\t * and:\n\t * - `x.y.z * a` ==> `[ member node `x.y.z`, identifier 'a']`\n\t * @param computed\n\t */\n\tdependency(computed?: true): ExpressionNode[];\n\n\t/**\n\t * ex:\n\t * ```js\n\t * x + y;\n\t * ```\n\t *\n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier:\tthe answer should be node `x`,\n\t * - for `y` identifier:\tthe answer should be node `y`.\n\t *\n\t * so, the return from `+` will be `['x', 'y']`\n\t *\n\t * and:\n\t * - `x.y.z` ==> `['x', 'y', 'z']`\n\t * - `x[y].z` ==> ['x', ]\n\t * @param computed required for member and chaining operators\n\t */\n\tdependencyPath(computed?: true): ExpressionEventPath[];\n\n\t/**\n\t * get all the events form this expression\n\t * \n\t * tha return from this method, is represent an answer for what is this expression depends-on as identifier name\n\t * \n\t * ex: \n\t * ```js\n\t * x + y;\n\t * ```\n\t * \n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier: the answer should be `x`\n\t * - for `y` identifier: the answer should be `y`\n\t * the final output will be \n\t * \n\t * so, the return from `+` will be `{ x: undefined, y: undefined }`\n\t * \n\t * and:\n\t * - `x.y.z * a` ==> `{ x: { y: { z: undefined }, a: undefined } }`\n\t * - `x.y.z > x.y.h.g` ==> `{ x: { y: { z: undefined, h: { g: undefined} } } }`\n\t * - `x[Symbol.toStringTag] + 'Class' + classType + array[3]` ==> `{ x: { 'Symbol.toStringTag': undefined }, classType: undefined,  array: { 3: undefined }  }`\n\t * - `'name'` ==> {}\n\t * - ```js\n\t * user[firstName + `son of ${fatherName}`]\n\t * ``` ==> `{ user: { 'firstName:fatherName': undefined }, firstName: undefined, fatherName: undefined }`\n\t * @param parent \n\t */\n\tevents(): ExpressionEventMap;\n\n\n\t/**\n\t * re-write this expression as a javascript source \n\t */\n\ttoString(): string;\n\n\t/**\n\t * used to map this object to represent an [ESTree](https://github.com/estree/estree) json object\n\t * @param key \n\t */\n\ttoJSON(): NodeJsonType;\n\n\t/**\n\t * just a helper method to force class that implement this interface to\n\t * have a static method `fromJSON` to help reconstruct this ExpressionNode\n\t * from an [ESTree](https://github.com/estree/estree) json object,\n\t * with all necessary implementation to execute the code\n\t */\n\tgetClass(): NodeExpressionClass<ExpressionNode>;\n}\n\ninterface TypeOf<T> {\n\tnew(...params: any[]): T;\n}\n\nexport type NodeDeserializer<N = ExpressionNode> = (node: N) => N;\n\nexport type VisitNodeType = (expression: ExpressionNode) => void;\nexport type VisitNodeListType = (expressions: ExpressionNode[]) => void;\n\n/**\n * this is how to:\n * describe a class with it's static functions and properties\n * in the interface add getClass method\n */\nexport interface NodeExpressionClass<N extends ExpressionNode> extends TypeOf<N> {\n\n\t/**\n\t * build expression node from [ESTree](https://github.com/estree/estree) json object\n\t * @param node \n\t * @param deserializer \n\t */\n\tfromJSON(node: N, deserializer: NodeDeserializer): N;\n\n\t/**\n\t * visit nodes inside expression\n\t * @param expression \n\t * @param callback \n\t */\n\tvisit?(node: N, visitNode: VisitNodeType, visitNodeList: VisitNodeListType): void;\n}\n\nexport interface NodeExpressionWithType<N extends ExpressionNode> extends NodeExpressionClass<N> {\n\n\t/**\n\t * the type of an expression\n\t */\n\ttype: string;\n}\n\nexport interface CanDeclareExpression extends ExpressionNode {\n\t/**\n\t * declare variable in the current local scope (block),\n\t * or closest function scope (global) scop,\n\t * the propertyName will be calculated at runtime\n\t * @param stack the stack which an identifier will be declared\n\t * @param propertyValue the initial value of identifier\n\t * @param scope which scop to declare this identifier\n\t */\n\tdeclareVariable(stack: Stack, scopeType: ScopeType, propertyValue?: any): any;\n}\n\n\n/**\n * An interface meant to be implemented by MemberExpression,\n * Identifier and ChainExpression and all Literal expressions\n */\nexport interface CanFindScope {\n\t/**\n\t * try to search for scope of this expression\n\t * @param stack \n\t */\n\tfindScope<T extends object>(stack: Stack): Scope<T>;\n\tfindScope<T extends object>(stack: Stack, scope: Scope<any>): Scope<T>;\n\tfindScope<T extends object>(stack: Stack, scope?: Scope<any>): Scope<T> | undefined;\n}\n"]}
+{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../../src/expressions/api/expression.ts"],"names":[],"mappings":"","sourcesContent":["import type { Scope, ScopeContext } from '../scope/scope.js';\nimport type { Stack } from '../scope/stack.js';\nimport { TypeOf } from './utils.js';\n\nexport type NodeType = { type: string };\nexport type NodeJsonType = { [key: string]: any } & NodeType;\n\nexport type ExpressionEventPathDotNotation = { computed: false, path: string };\nexport type ExpressionEventPathBracketNotation = { computed: true, path: string, computedPath: ExpressionEventPath[][] };\nexport type ExpressionEventPath = ExpressionEventPathDotNotation | ExpressionEventPathBracketNotation;\nexport type ExpressionEventMap = { [key: string]: ExpressionEventMap };\n\nexport interface ExpressionNode {\n\n\t/**\n\t * pass scope list from outer function to inner function,\n\t * \n\t * all other end point expression should do nothing,\n\t *  if this function executed.\n\t * \n\t * @param scopeList all outer function scopes given to the inner function,\n\t * this solution ignore the fact that some inner function has no need to\n\t * get shared variables, as its implementation never say that\n\t * ```js\n\t * function f(d) {\n\t * \t\tfunction g() {\n\t * \t\t\tconst a = ({ d }) => d;\n\t * \t\t\treturn a;\n\t * \t\t}\n\t * \t\treturn [d, g];\n\t * }\n\t * ```\n\t */\n\tshareVariables(scopeList: Scope<ScopeContext>[]): void;\n\n\t/**\n\t * assign the value to this expression in stack.\n\t * \n\t * most ExpressionNode will not implement this method, and will throw an exception.\n\t * @param stack \n\t * @param value \n\t */\n\tset(stack: Stack, value: any): any;\n\n\t/**\n\t * execute/get the code for this expression and return the result value.\n\t * @param stack \n\t * @param thisContext \n\t */\n\tget(stack: Stack, thisContext?: any): any;\n\n\t/**\n\t * get all dependencies form an expression node\n\t *\n\t * tha return from this method, is represent an answer for what identifiers this expression depends-on.\n\t * \n\t *\n\t * ex:\n\t * ```js\n\t * x + y;\n\t * ```\n\t *\n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier:\tthe answer should be node `x`,\n\t * - for `y` identifier:\tthe answer should be node `y`.\n\t *\n\t * so, the return from `+` will be `[ node 'x', node 'y']`\n\t *\n\t * and:\n\t * - `x.y.z * a` ==> `[ member node `x.y.z`, identifier 'a']`\n\t * @param computed\n\t */\n\tdependency(computed?: true): ExpressionNode[];\n\n\t/**\n\t * ex:\n\t * ```js\n\t * x + y;\n\t * ```\n\t *\n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier:\tthe answer should be node `x`,\n\t * - for `y` identifier:\tthe answer should be node `y`.\n\t *\n\t * so, the return from `+` will be `['x', 'y']`\n\t *\n\t * and:\n\t * - `x.y.z` ==> `['x', 'y', 'z']`\n\t * - `x[y].z` ==> ['x', ]\n\t * @param computed required for member and chaining operators\n\t */\n\tdependencyPath(computed?: true): ExpressionEventPath[];\n\n\t/**\n\t * get all the events form this expression\n\t * \n\t * tha return from this method, is represent an answer for what is this expression depends-on as identifier name\n\t * \n\t * ex: \n\t * ```js\n\t * x + y;\n\t * ```\n\t * \n\t * - for `+` operator :\tthe answer should be `lhs` and `rhs`,\n\t * - for `x` identifier: the answer should be `x`\n\t * - for `y` identifier: the answer should be `y`\n\t * the final output will be \n\t * \n\t * so, the return from `+` will be `{ x: undefined, y: undefined }`\n\t * \n\t * and:\n\t * - `x.y.z * a` ==> `{ x: { y: { z: undefined }, a: undefined } }`\n\t * - `x.y.z > x.y.h.g` ==> `{ x: { y: { z: undefined, h: { g: undefined} } } }`\n\t * - `x[Symbol.toStringTag] + 'Class' + classType + array[3]` ==> `{ x: { 'Symbol.toStringTag': undefined }, classType: undefined,  array: { 3: undefined }  }`\n\t * - `'name'` ==> {}\n\t * - ```js\n\t * user[firstName + `son of ${fatherName}`]\n\t * ``` ==> `{ user: { 'firstName:fatherName': undefined }, firstName: undefined, fatherName: undefined }`\n\t * @param parent \n\t */\n\tevents(): ExpressionEventMap;\n\n\n\t/**\n\t * re-write this expression as a javascript source \n\t */\n\ttoString(): string;\n\n\t/**\n\t * used to map this object to represent an [ESTree](https://github.com/estree/estree) json object\n\t * @param key \n\t */\n\ttoJSON(): NodeJsonType;\n\n\t/**\n\t * just a helper method to force class that implement this interface to\n\t * have a static method `fromJSON` to help reconstruct this ExpressionNode\n\t * from an [ESTree](https://github.com/estree/estree) json object,\n\t * with all necessary implementation to execute the code\n\t */\n\tgetClass(): ExpressionNodConstructor<ExpressionNode>;\n}\n\nexport type NodeDeserializer<N = ExpressionNode> = (node: N) => N;\n\nexport type VisitNodeType = (expression: ExpressionNode) => void;\n\n/**\n * this is how to:\n * describe a class with it's static functions and properties\n * in the interface add getClass method\n */\nexport interface ExpressionNodConstructor<N extends ExpressionNode> extends TypeOf<N> {\n\n\t/**\n\t * the type of an expression\n\t */\n\ttype: string;\n\n\t/**\n\t * build expression node from [ESTree](https://github.com/estree/estree) json object\n\t * @param node \n\t * @param deserializer \n\t */\n\tfromJSON(node: N, deserializer: NodeDeserializer): N;\n\n\t/**\n\t * visit nodes inside expression\n\t * @param expression \n\t * @param callback \n\t */\n\tvisit?(node: N, visitNode: Object): void;\n}\n\nexport interface DeclarationExpression extends ExpressionNode {\n\t/**\n\t * declare variable in the current local scope (block),\n\t * or closest function scope (global) scop,\n\t * the propertyName will be calculated at runtime\n\t * @param stack the stack which an identifier will be declared\n\t * @param propertyValue the initial value of identifier\n\t * @param scope which scop to declare this identifier\n\t */\n\tdeclareVariable(stack: Stack, propertyValue?: any): any;\n\n\t/**\n\t * get the variable declaration name\n\t */\n\tgetDeclarationName?(): string;\n}\n\n\n/**\n * An interface meant to be implemented by MemberExpression,\n * Identifier and ChainExpression and all Literal expressions\n */\nexport interface CanFindScope {\n\t/**\n\t * try to search for scope of this expression\n\t * @param stack \n\t */\n\tfindScope<T extends ScopeContext>(stack: Stack): Scope<T>;\n\tfindScope<T extends ScopeContext>(stack: Stack, scope: Scope<ScopeContext>): Scope<T>;\n\tfindScope<T extends ScopeContext>(stack: Stack, scope?: Scope<ScopeContext>): Scope<T> | undefined;\n}\n"]}

package/api/index.d.ts

@@ -1,6 +1,7 @@
 export * from './expression.js';
 export * from './abstract.js';
 export * from './deserialize/deserialize.js';
+export * from './program.js';
 export * from './definition/values.js';
 export * from './definition/array.js';
 export * from './definition/comment.js';
@@ -10,6 +11,7 @@ export * from './definition/bind.js';
 export * from './definition/object.js';
 export * from './definition/statement.js';
 export * from './computing/call.js';
+export * from './computing/debugger.js';
 export * from './computing/new.js';
 export * from './computing/return.js';
 export * from './computing/spread.js';

package/api/index.js

@@ -1,6 +1,7 @@
 export * from './expression.js';
 export * from './abstract.js';
 export * from './deserialize/deserialize.js';
+export * from './program.js';
 export * from './definition/values.js';
 export * from './definition/array.js';
 export * from './definition/comment.js';
@@ -10,6 +11,7 @@ export * from './definition/bind.js';
 export * from './definition/object.js';
 export * from './definition/statement.js';
 export * from './computing/call.js';
+export * from './computing/debugger.js';
 export * from './computing/new.js';
 export * from './computing/return.js';
 export * from './computing/spread.js';

package/api/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/expressions/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAE7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAE1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AAErC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,sCAAsC,CAAC;AAErD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC","sourcesContent":["export * from './expression.js';\nexport * from './abstract.js';\n\nexport * from './deserialize/deserialize.js';\n\nexport * from './definition/values.js';\nexport * from './definition/array.js';\nexport * from './definition/comment.js';\nexport * from './definition/function.js';\nexport * from './definition/member.js';\nexport * from './definition/bind.js';\nexport * from './definition/object.js';\nexport * from './definition/statement.js';\n\nexport * from './computing/call.js';\nexport * from './computing/new.js';\nexport * from './computing/return.js';\nexport * from './computing/spread.js';\nexport * from './computing/rest.js';\nexport * from './computing/throw.js';\nexport * from './computing/yield.js';\n\nexport * from './operators/assignment.js';\nexport * from './operators/await.js';\nexport * from './operators/binary.js';\nexport * from './operators/chaining.js';\nexport * from './operators/comma.js';\nexport * from './operators/grouping.js';\nexport * from './operators/logical.js';\nexport * from './operators/pipeline.js';\nexport * from './operators/ternary.js';\nexport * from './operators/types.js';\nexport * from './operators/unary.js';\nexport * from './operators/update.js';\n\nexport * from './statement/control/block.js';\nexport * from './statement/control/empty.js';\nexport * from './statement/control/if.js';\nexport * from './statement/control/switch.js';\nexport * from './statement/control/terminate.js';\n\nexport * from './statement/declarations/declares.js';\n\nexport * from './statement/iterations/for.js';\nexport * from './statement/iterations/while.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/expressions/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAE7C,cAAc,cAAc,CAAC;AAE7B,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAE1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AAErC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,sCAAsC,CAAC;AAErD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC","sourcesContent":["export * from './expression.js';\nexport * from './abstract.js';\n\nexport * from './deserialize/deserialize.js';\n\nexport * from './program.js';\n\nexport * from './definition/values.js';\nexport * from './definition/array.js';\nexport * from './definition/comment.js';\nexport * from './definition/function.js';\nexport * from './definition/member.js';\nexport * from './definition/bind.js';\nexport * from './definition/object.js';\nexport * from './definition/statement.js';\n\nexport * from './computing/call.js';\nexport * from './computing/debugger.js';\nexport * from './computing/new.js';\nexport * from './computing/return.js';\nexport * from './computing/spread.js';\nexport * from './computing/rest.js';\nexport * from './computing/throw.js';\nexport * from './computing/yield.js';\n\nexport * from './operators/assignment.js';\nexport * from './operators/await.js';\nexport * from './operators/binary.js';\nexport * from './operators/chaining.js';\nexport * from './operators/comma.js';\nexport * from './operators/grouping.js';\nexport * from './operators/logical.js';\nexport * from './operators/pipeline.js';\nexport * from './operators/ternary.js';\nexport * from './operators/types.js';\nexport * from './operators/unary.js';\nexport * from './operators/update.js';\n\nexport * from './statement/control/block.js';\nexport * from './statement/control/empty.js';\nexport * from './statement/control/if.js';\nexport * from './statement/control/switch.js';\nexport * from './statement/control/terminate.js';\n\nexport * from './statement/declarations/declares.js';\n\nexport * from './statement/iterations/for.js';\nexport * from './statement/iterations/while.js';\n"]}

package/api/module/common.d.ts

@@ -0,0 +1,29 @@
+import { Scope } from '../../scope/scope.js';
+import { Stack } from '../../scope/stack.js';
+import { AbstractExpressionNode } from '../abstract.js';
+import { Identifier, Literal } from '../definition/values.js';
+import { ExpressionEventPath, ExpressionNode, NodeDeserializer, VisitNodeType } from '../expression.js';
+export declare abstract class ModuleSpecifier extends AbstractExpressionNode {
+    protected local: Identifier;
+    constructor(local: Identifier);
+    getLocal(): Identifier;
+    toJson(): object;
+}
+export declare class ImportAttribute extends AbstractExpressionNode {
+    private key;
+    private value;
+    static fromJSON(node: ImportAttribute, deserializer: NodeDeserializer): ImportAttribute;
+    static visit(node: ImportAttribute, visitNode: VisitNodeType): void;
+    constructor(key: Identifier | Literal<string>, value: Literal<string>);
+    getKey(): Identifier | Literal<string>;
+    getValue(): Literal<string>;
+    shareVariables(scopeList: Scope<any>[]): void;
+    set(stack: Stack, value: any): void;
+    get(stack: Stack, thisContext?: any): {
+        [key: string]: string;
+    };
+    dependency(computed?: true): ExpressionNode[];
+    dependencyPath(computed?: true): ExpressionEventPath[];
+    toString(): string;
+    toJson(): object;
+}

package/api/module/common.js

@@ -0,0 +1,71 @@
+var ImportAttribute_1;
+import { __decorate, __metadata } from "tslib";
+import { AbstractExpressionNode } from '../abstract.js';
+import { Literal } from '../definition/values.js';
+import { Deserializer } from '../deserialize/deserialize.js';
+export class ModuleSpecifier extends AbstractExpressionNode {
+    constructor(local) {
+        super();
+        this.local = local;
+    }
+    getLocal() {
+        return this.local;
+    }
+    toJson() {
+        return {
+            local: this.local.toJSON()
+        };
+    }
+}
+let ImportAttribute = ImportAttribute_1 = class ImportAttribute extends AbstractExpressionNode {
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+    }
+    static fromJSON(node, deserializer) {
+        return new ImportAttribute_1(deserializer(node.key), deserializer(node.value));
+    }
+    static visit(node, visitNode) {
+        visitNode(node.key);
+        visitNode(node.value);
+    }
+    getKey() {
+        return this.key;
+    }
+    getValue() {
+        return this.value;
+    }
+    shareVariables(scopeList) {
+        throw new Error('Method not implemented.');
+    }
+    set(stack, value) {
+        throw new Error('Method not implemented.');
+    }
+    get(stack, thisContext) {
+        const key = this.key.get(stack);
+        const value = this.value.get();
+        return { [key]: value };
+    }
+    dependency(computed) {
+        return [];
+    }
+    dependencyPath(computed) {
+        return [];
+    }
+    toString() {
+        return `${this.key.toString()}: ${this.value.toString()}`;
+    }
+    toJson() {
+        return {
+            key: this.key.toJSON(),
+            value: this.value.toJSON(),
+        };
+    }
+};
+ImportAttribute = ImportAttribute_1 = __decorate([
+    Deserializer('ImportAttribute'),
+    __metadata("design:paramtypes", [Object, Literal])
+], ImportAttribute);
+export { ImportAttribute };
+//# sourceMappingURL=common.js.map

package/api/module/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/expressions/api/module/common.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAc,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,MAAM,OAAgB,eAAgB,SAAQ,sBAAsB;IACnE,YAAsB,KAAiB;QACtC,KAAK,EAAE,CAAC;QADa,UAAK,GAAL,KAAK,CAAY;IAEvC,CAAC;IACD,QAAQ;QACP,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IACD,MAAM;QACL,OAAO;YACN,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;SAC1B,CAAC;IACH,CAAC;CACD;AAKD,IAAa,eAAe,uBAA5B,MAAa,eAAgB,SAAQ,sBAAsB;IAY1D,YAAoB,GAAiC,EAAU,KAAsB;QACpF,KAAK,EAAE,CAAC;QADW,QAAG,GAAH,GAAG,CAA8B;QAAU,UAAK,GAAL,KAAK,CAAiB;IAErF,CAAC;IAbD,MAAM,CAAC,QAAQ,CAAC,IAAqB,EAAE,YAA8B;QACpE,OAAO,IAAI,iBAAe,CACzB,YAAY,CAAC,IAAI,CAAC,GAAG,CAAe,EACpC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAoB,CAC3C,CAAC;IACH,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,IAAqB,EAAE,SAAwB;QAC3D,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAKD,MAAM;QACL,OAAO,IAAI,CAAC,GAAG,CAAC;IACjB,CAAC;IACD,QAAQ;QACP,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IACD,cAAc,CAAC,SAAuB;QACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC5C,CAAC;IACD,GAAG,CAAC,KAAY,EAAE,KAAU;QAC3B,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC5C,CAAC;IACD,GAAG,CAAC,KAAY,EAAE,WAAiB;QAClC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC/B,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC;IACzB,CAAC;IACD,UAAU,CAAC,QAAe;QACzB,OAAO,EAAE,CAAC;IACX,CAAC;IACD,cAAc,CAAC,QAAe;QAC7B,OAAO,EAAE,CAAC;IACX,CAAC;IACD,QAAQ;QACP,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC3D,CAAC;IACD,MAAM;QACL,OAAO;YACN,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;YACtB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;SAC1B,CAAC;IACH,CAAC;CACD,CAAA;AA/CY,eAAe;IAD3B,YAAY,CAAC,iBAAiB,CAAC;6CAauC,OAAO;GAZjE,eAAe,CA+C3B;SA/CY,eAAe","sourcesContent":["import { Scope } from '../../scope/scope.js';\nimport { Stack } from '../../scope/stack.js';\nimport { AbstractExpressionNode } from '../abstract.js';\nimport { Identifier, Literal } from '../definition/values.js';\nimport { Deserializer } from '../deserialize/deserialize.js';\nimport { ExpressionEventPath, ExpressionNode, NodeDeserializer, VisitNodeType } from '../expression.js';\n\nexport abstract class ModuleSpecifier extends AbstractExpressionNode {\n\tconstructor(protected local: Identifier) {\n\t\tsuper();\n\t}\n\tgetLocal() {\n\t\treturn this.local;\n\t}\n\ttoJson(): object {\n\t\treturn {\n\t\t\tlocal: this.local.toJSON()\n\t\t};\n\t}\n}\n\n\n\n@Deserializer('ImportAttribute')\nexport class ImportAttribute extends AbstractExpressionNode {\n\tstatic fromJSON(node: ImportAttribute, deserializer: NodeDeserializer): ImportAttribute {\n\t\treturn new ImportAttribute(\n\t\t\tdeserializer(node.key) as Identifier,\n\t\t\tdeserializer(node.value) as Literal<string>\n\t\t);\n\t}\n\tstatic visit(node: ImportAttribute, visitNode: VisitNodeType): void {\n\t\tvisitNode(node.key);\n\t\tvisitNode(node.value);\n\t}\n\n\tconstructor(private key: Identifier | Literal<string>, private value: Literal<string>) {\n\t\tsuper();\n\t}\n\tgetKey() {\n\t\treturn this.key;\n\t}\n\tgetValue() {\n\t\treturn this.value;\n\t}\n\tshareVariables(scopeList: Scope<any>[]): void {\n\t\tthrow new Error('Method not implemented.');\n\t}\n\tset(stack: Stack, value: any) {\n\t\tthrow new Error('Method not implemented.');\n\t}\n\tget(stack: Stack, thisContext?: any): { [key: string]: string } {\n\t\tconst key = this.key.get(stack);\n\t\tconst value = this.value.get();\n\t\treturn { [key]: value };\n\t}\n\tdependency(computed?: true): ExpressionNode[] {\n\t\treturn [];\n\t}\n\tdependencyPath(computed?: true): ExpressionEventPath[] {\n\t\treturn [];\n\t}\n\ttoString(): string {\n\t\treturn `${this.key.toString()}: ${this.value.toString()}`;\n\t}\n\ttoJson(): object {\n\t\treturn {\n\t\t\tkey: this.key.toJSON(),\n\t\t\tvalue: this.value.toJSON(),\n\t\t};\n\t}\n}\n"]}

package/api/module/export.d.ts

@@ -1,31 +1,135 @@
-import type { NodeDeserializer, ExpressionNode, ExpressionEventPath, VisitNodeType, VisitNodeListType } from '../expression.js';
-import type { Scope } from '../../scope/scope.js';
-import type { Stack } from '../../scope/stack.js';
+/**
+ *  There are two types of exports:
+ * 1- Named Exports (Zero or more exports per module)
+ * 2- Default Exports (One per module)
+ *
+ * // Exporting individual features
+ * export let name1, name2, …, nameN; // also var, const
+ * export let name1 = …, name2 = …, …, nameN; // also var, const
+ * export function functionName(){...}
+ * export class ClassName {...}
+ *
+ * // Export list
+ * export { name1, name2, …, nameN };
+ *
+ * // Renaming exports
+ * export { variable1 as name1, variable2 as name2, …, nameN };
+ *
+ * // Exporting destructed assignments with renaming
+ * export const { name1, name2: bar } = o;
+ *
+ * // Default exports
+ * export default expression;
+ * export default function (…) { … } // also class, function*
+ * export default function name1(…) { … } // also class, function*
+ * export { name1 as default, … };
+ *
+ * // Aggregating modules
+ * export * from …; // does not set the default export
+ * export * as name1 from …; // Draft ECMAScript® 2O21
+ * export { name1, name2, …, nameN } from …;
+ * export { import1 as name1, import2 as name2, …, nameN } from …;
+ * export { default, … } from …;
+ */
+import type { NodeDeserializer, ExpressionNode, ExpressionEventPath, VisitNodeType, DeclarationExpression } from '../expression.js';
+import { Scope } from '../../scope/scope.js';
+import { Stack } from '../../scope/stack.js';
 import { AbstractExpressionNode } from '../abstract.js';
-export declare class ExportAliasName {
-    exportName: ExpressionNode;
-    protected _aliasName?: ExpressionNode | undefined;
-    static visit(node: ExportAliasName, visitNode: VisitNodeType, visitNodeList: VisitNodeListType): void;
-    constructor(exportName: ExpressionNode, _aliasName?: ExpressionNode | undefined);
-    get aliasName(): ExpressionNode;
-    set aliasName(_aliasName: ExpressionNode);
+import { Identifier, Literal } from '../definition/values.js';
+import { ImportAttribute, ModuleSpecifier } from './common.js';
+import { FunctionDeclaration } from '../definition/function.js';
+import { ClassDeclaration } from '../class/class.js';
+/**
+ * An exported variable binding, e.g., `{foo}` in `export {foo}` or `{bar as foo}` in `export {bar as foo}`.
+ *
+ * The `exported` field refers to the name exported in the module.
+ *
+ * The `local` field refers to the binding into the local module scope.
+ *
+ * If it is a basic named export, such as in `export {foo}`, both `exported` and `local` are equivalent `Identifier` nodes;
+ * in this case an Identifier node representing `foo`.
+ *
+ * If it is an aliased export,
+ * such as in `export {bar as foo}`, the `exported` field is an `Identifier` node representing `foo`,
+ * and the `local` field is an `Identifier` node representing `bar`.
+ */
+export declare class ExportSpecifier extends ModuleSpecifier {
+    private exported;
+    static fromJSON(node: ExportSpecifier, deserializer: NodeDeserializer): ExportSpecifier;
+    static visit(node: ExportSpecifier, visitNode: VisitNodeType): void;
+    constructor(local: Identifier, exported: Identifier);
+    getExported(): Identifier;
+    shareVariables(scopeList: Scope<any>[]): void;
+    set(stack: Stack, value: any): void;
+    get(stack: Stack, thisContext?: any): void;
+    dependency(computed?: true): ExpressionNode[];
+    dependencyPath(computed?: true): ExpressionEventPath[];
+    toString(): string;
+    toJson(): object;
+}
+/**
+ * An export named declaration, e.g.,
+ * `export {foo, bar};`,
+ * `export {foo} from "mod";`
+ * or `export var foo = 1;`.
+ *
+ * Note: Having `declaration` populated with non-empty `specifiers` or non-null `source` results in an invalid state.
+ */
+export declare class ExportNamedDeclaration extends AbstractExpressionNode {
+    private specifiers;
+    private declaration?;
+    private source?;
+    private assertions?;
+    static fromJSON(node: ExportNamedDeclaration, deserializer: NodeDeserializer): ExportNamedDeclaration;
+    static visit(node: ExportNamedDeclaration, visitNode: VisitNodeType): void;
+    constructor(specifiers: ExportSpecifier[], declaration?: DeclarationExpression | undefined, source?: Literal<string> | undefined, assertions?: ImportAttribute[] | undefined);
+    getSource(): Literal<string> | undefined;
+    getSpecifiers(): ExportSpecifier[];
+    getDeclaration(): DeclarationExpression | undefined;
+    getAssertions(): ImportAttribute[] | undefined;
+    shareVariables(scopeList: Scope<any>[]): void;
+    set(stack: Stack): void;
+    get(stack: Stack): void;
+    private exportDeclaration;
+    private exportFromSource;
+    private exportLocal;
+    dependency(computed?: true): ExpressionNode[];
+    dependencyPath(computed?: true): ExpressionEventPath[];
+    toString(): string;
+    toJson(): object;
+}
+/**
+ * An export default declaration, e.g.,
+ * `export default function () {};`
+ * or `export default 1;`.
+ */
+export declare class ExportDefaultDeclaration extends AbstractExpressionNode {
+    private declaration;
+    static fromJSON(node: ExportDefaultDeclaration, deserializer: NodeDeserializer): ExportDefaultDeclaration;
+    static visit(node: ExportDefaultDeclaration, visitNode: VisitNodeType): void;
+    constructor(declaration: FunctionDeclaration | ClassDeclaration | ExpressionNode);
+    getDeclaration(): ExpressionNode | FunctionDeclaration | ClassDeclaration;
+    shareVariables(scopeList: Scope<any>[]): void;
+    set(stack: Stack): void;
+    get(stack: Stack): void;
+    dependency(computed?: true): ExpressionNode[];
+    dependencyPath(computed?: true): ExpressionEventPath[];
     toString(): string;
-    toJSON(): {
-        exportName: import("../expression.js").NodeJsonType;
-        aliasName: import("../expression.js").NodeJsonType | undefined;
-    };
+    toJson(): object;
 }
-export declare class ExportNode extends AbstractExpressionNode {
-    private exportList?;
-    private starExport?;
-    private exportExpression?;
-    private moduleName?;
-    static fromJSON(node: ExportNode, deserializer: NodeDeserializer): ExportNode;
-    static visit(node: ExportNode, visitNode: VisitNodeType, visitNodeList: VisitNodeListType): void;
-    constructor(exportList?: ExportAliasName[] | undefined, starExport?: ExportAliasName | undefined, exportExpression?: ExportAliasName | undefined, moduleName?: ExpressionNode | undefined);
-    getModuleName(): ExpressionNode | undefined;
-    getExportExpression(): ExportAliasName | undefined;
-    getExportList(): ExportAliasName[] | undefined;
+/**
+ * An export batch declaration, e.g., `export * from "mod";`.
+ */
+export declare class ExportAllDeclaration extends AbstractExpressionNode {
+    private source;
+    private exported?;
+    private assertions?;
+    static fromJSON(node: ExportAllDeclaration, deserializer: NodeDeserializer): ExportAllDeclaration;
+    static visit(node: ExportAllDeclaration, visitNode: VisitNodeType): void;
+    constructor(source: Literal<string>, exported?: Identifier | undefined, assertions?: ImportAttribute[] | undefined);
+    getSource(): Literal<string>;
+    getExported(): Identifier | undefined;
+    getAssertions(): ImportAttribute[] | undefined;
     shareVariables(scopeList: Scope<any>[]): void;
     set(stack: Stack): void;
     get(stack: Stack): void;