@ibyar/expressions 0.8.6 → 1.0.0

package/api/module/import.js

@@ -1,8 +1,6 @@
-var ImportSpecifier_1, ImportDefaultSpecifier_1, ImportNamespaceSpecifier_1, ImportDeclaration_1, ImportExpression_1;
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { AbstractExpressionNode } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
-import { Identifier, Literal } from '../definition/values.js';
 import { ModuleSpecifier } from './common.js';
 /**
  * An imported variable binding,
@@ -21,117 +19,140 @@ import { ModuleSpecifier } from './common.js';
  * the imported field is an Identifier node representing foo,
  * and the local field is an Identifier node representing bar.
  */
-let ImportSpecifier = ImportSpecifier_1 = class ImportSpecifier extends ModuleSpecifier {
-    static fromJSON(node, deserializer) {
-        return new ImportSpecifier_1(deserializer(node.local), deserializer(node.imported), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.local);
-        visitNode(node.imported);
-    }
-    constructor(local, imported, range, loc) {
-        super(local, range, loc);
-        this.imported = imported;
-    }
-    getImported() {
-        return this.imported;
-    }
-    getImportedName() {
-        return this.imported.getName();
-    }
-    set(stack, value) {
-        throw new Error('Method not implemented.');
-    }
-    get(stack, thisContext) {
-        throw new Error('Method not implemented.');
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        const local = this.local.toString();
-        const imported = this.imported.toString();
-        if (local == imported) {
-            return local;
-        }
-        return `${imported} as ${local}`;
-    }
-    toJson() {
-        return {
-            local: this.local.toJSON(),
-            imported: this.imported.toJSON()
-        };
-    }
-};
-ImportSpecifier = ImportSpecifier_1 = __decorate([
-    Deserializer('ImportSpecifier'),
-    __metadata("design:paramtypes", [Identifier,
-        Identifier, Array, Object])
-], ImportSpecifier);
-export { ImportSpecifier };
+export let ImportSpecifier = (() => {
+    let _classDecorators = [Deserializer('ImportSpecifier')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ImportSpecifier = class extends ModuleSpecifier {
+        static {
+            __esDecorate(null, _classDescriptor = { value: this }, _classDecorators, { kind: "class", name: this.name }, null, _classExtraInitializers);
+            ImportSpecifier = _classThis = _classDescriptor.value;
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        imported;
+        static fromJSON(node, deserializer) {
+            return new ImportSpecifier(deserializer(node.local), deserializer(node.imported), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.local);
+            visitNode(node.imported);
+        }
+        constructor(local, imported, range, loc) {
+            super(local, range, loc);
+            this.imported = imported;
+        }
+        getImported() {
+            return this.imported;
+        }
+        getImportedName() {
+            return this.imported.getName();
+        }
+        set(stack, value) {
+            throw new Error('Method not implemented.');
+        }
+        get(stack, thisContext) {
+            throw new Error('Method not implemented.');
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            const local = this.local.toString();
+            const imported = this.imported.toString();
+            if (local == imported) {
+                return local;
+            }
+            return `${imported} as ${local}`;
+        }
+        toJson() {
+            return {
+                local: this.local.toJSON(),
+                imported: this.imported.toJSON()
+            };
+        }
+    };
+    return ImportSpecifier = _classThis;
+})();
 /**
  * A default import specifier, e.g., `foo` in `import foo from "mod.js";`.
  */
-let ImportDefaultSpecifier = ImportDefaultSpecifier_1 = class ImportDefaultSpecifier extends ModuleSpecifier {
-    static fromJSON(node, deserializer) {
-        return new ImportDefaultSpecifier_1(deserializer(node.local), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.local);
-    }
-    set(stack, value) {
-        throw new Error('Method not implemented.');
-    }
-    get(stack, thisContext) {
-        throw new Error('Method not implemented.');
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        return this.local.toString();
-    }
-};
-ImportDefaultSpecifier = ImportDefaultSpecifier_1 = __decorate([
-    Deserializer('ImportDefaultSpecifier')
-], ImportDefaultSpecifier);
-export { ImportDefaultSpecifier };
+export let ImportDefaultSpecifier = (() => {
+    let _classDecorators_1 = [Deserializer('ImportDefaultSpecifier')];
+    let _classDescriptor_1;
+    let _classExtraInitializers_1 = [];
+    let _classThis_1;
+    var ImportDefaultSpecifier = class extends ModuleSpecifier {
+        static {
+            __esDecorate(null, _classDescriptor_1 = { value: this }, _classDecorators_1, { kind: "class", name: this.name }, null, _classExtraInitializers_1);
+            ImportDefaultSpecifier = _classThis_1 = _classDescriptor_1.value;
+            __runInitializers(_classThis_1, _classExtraInitializers_1);
+        }
+        static fromJSON(node, deserializer) {
+            return new ImportDefaultSpecifier(deserializer(node.local), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.local);
+        }
+        set(stack, value) {
+            throw new Error('Method not implemented.');
+        }
+        get(stack, thisContext) {
+            throw new Error('Method not implemented.');
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            return this.local.toString();
+        }
+    };
+    return ImportDefaultSpecifier = _classThis_1;
+})();
 /**
  * A namespace import specifier, e.g., `* as foo` in `import * as foo from "mod.js";`.
  */
-let ImportNamespaceSpecifier = ImportNamespaceSpecifier_1 = class ImportNamespaceSpecifier extends ModuleSpecifier {
-    static fromJSON(node, deserializer) {
-        return new ImportNamespaceSpecifier_1(deserializer(node.local), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.local);
-    }
-    set(stack, value) {
-        throw new Error('Method not implemented.');
-    }
-    get(stack, thisContext) {
-        throw new Error('Method not implemented.');
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        return `* as ${this.local.toString()}`;
-    }
-};
-ImportNamespaceSpecifier = ImportNamespaceSpecifier_1 = __decorate([
-    Deserializer('ImportNamespaceSpecifier')
-], ImportNamespaceSpecifier);
-export { ImportNamespaceSpecifier };
+export let ImportNamespaceSpecifier = (() => {
+    let _classDecorators_2 = [Deserializer('ImportNamespaceSpecifier')];
+    let _classDescriptor_2;
+    let _classExtraInitializers_2 = [];
+    let _classThis_2;
+    var ImportNamespaceSpecifier = class extends ModuleSpecifier {
+        static {
+            __esDecorate(null, _classDescriptor_2 = { value: this }, _classDecorators_2, { kind: "class", name: this.name }, null, _classExtraInitializers_2);
+            ImportNamespaceSpecifier = _classThis_2 = _classDescriptor_2.value;
+            __runInitializers(_classThis_2, _classExtraInitializers_2);
+        }
+        static fromJSON(node, deserializer) {
+            return new ImportNamespaceSpecifier(deserializer(node.local), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.local);
+        }
+        set(stack, value) {
+            throw new Error('Method not implemented.');
+        }
+        get(stack, thisContext) {
+            throw new Error('Method not implemented.');
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            return `* as ${this.local.toString()}`;
+        }
+    };
+    return ImportNamespaceSpecifier = _classThis_2;
+})();
 /**
  * An import declaration, e.g., import foo from "mod";.
  *
@@ -156,165 +177,184 @@ export { ImportNamespaceSpecifier };
  * import "module-name";
  *
  */
-let ImportDeclaration = ImportDeclaration_1 = class ImportDeclaration extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ImportDeclaration_1(deserializer(node.source), node.specifiers?.map(deserializer), node.assertions?.map(deserializer), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.source);
-        node.specifiers?.forEach(visitNode);
-        node.assertions?.forEach(visitNode);
-    }
-    constructor(source, specifiers, assertions, range, loc) {
-        super(range, loc);
-        this.source = source;
-        this.specifiers = specifiers;
-        this.assertions = assertions;
-    }
-    getSource() {
-        return this.source;
-    }
-    getSpecifiers() {
-        return this.specifiers;
-    }
-    getAssertions() {
-        return this.assertions;
-    }
-    set(stack) {
-        throw new Error(`ImportDeclaration.#set() has no implementation.`);
-    }
-    get(stack) {
-        let importCallOptions;
-        if (this.assertions) {
-            const importAssertions = this.assertions
-                .map(assertion => assertion.get(stack))
-                .reduce((p, c) => Object.assign(p, c), {});
-            if (importAssertions) {
-                importCallOptions = { assert: importAssertions };
+export let ImportDeclaration = (() => {
+    let _classDecorators_3 = [Deserializer('ImportDeclaration')];
+    let _classDescriptor_3;
+    let _classExtraInitializers_3 = [];
+    let _classThis_3;
+    var ImportDeclaration = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_3 = { value: this }, _classDecorators_3, { kind: "class", name: this.name }, null, _classExtraInitializers_3);
+            ImportDeclaration = _classThis_3 = _classDescriptor_3.value;
+            __runInitializers(_classThis_3, _classExtraInitializers_3);
+        }
+        source;
+        specifiers;
+        assertions;
+        static fromJSON(node, deserializer) {
+            return new ImportDeclaration(deserializer(node.source), node.specifiers?.map(deserializer), node.assertions?.map(deserializer), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.source);
+            node.specifiers?.forEach(visitNode);
+            node.assertions?.forEach(visitNode);
+        }
+        constructor(source, specifiers, assertions, range, loc) {
+            super(range, loc);
+            this.source = source;
+            this.specifiers = specifiers;
+            this.assertions = assertions;
+        }
+        getSource() {
+            return this.source;
+        }
+        getSpecifiers() {
+            return this.specifiers;
+        }
+        getAssertions() {
+            return this.assertions;
+        }
+        set(stack) {
+            throw new Error(`ImportDeclaration.#set() has no implementation.`);
+        }
+        get(stack) {
+            let importCallOptions;
+            if (this.assertions) {
+                const importAssertions = this.assertions
+                    .map(assertion => assertion.get(stack))
+                    .reduce((p, c) => Object.assign(p, c), {});
+                if (importAssertions) {
+                    importCallOptions = { assert: importAssertions };
+                }
             }
+            const module = stack.importModule(this.source.get(), importCallOptions);
+            if (!this.specifiers) {
+                return;
+            }
+            this.specifiers.forEach(specifier => {
+                const local = specifier.getLocalName();
+                if (specifier instanceof ImportSpecifier) {
+                    const imported = specifier.getImportedName();
+                    const importedValue = module.get(imported);
+                    stack.getModule()?.set(local, importedValue);
+                    const scopeSubscription = module.subscribe(local, (newValue, oldValue) => {
+                        if (newValue !== oldValue) {
+                            stack.getModule()?.set(local, newValue);
+                        }
+                    });
+                    stack.onDestroy(() => scopeSubscription.unsubscribe());
+                }
+                else if (specifier instanceof ImportDefaultSpecifier) {
+                    const defaultValue = module.get('default');
+                    stack.getModule()?.set(local, defaultValue);
+                    const scopeSubscription = module.subscribe('default', (newValue, oldValue) => {
+                        if (newValue !== oldValue) {
+                            stack.getModule()?.set(local, newValue);
+                        }
+                    });
+                    stack.onDestroy(() => scopeSubscription.unsubscribe());
+                }
+                else if (specifier instanceof ImportNamespaceSpecifier) {
+                    stack.getModule()?.importModule(local, module);
+                }
+            });
+        }
+        dependency(computed) {
+            return [];
         }
-        const module = stack.importModule(this.source.get(), importCallOptions);
-        if (!this.specifiers) {
-            return;
-        }
-        this.specifiers.forEach(specifier => {
-            const local = specifier.getLocalName();
-            if (specifier instanceof ImportSpecifier) {
-                const imported = specifier.getImportedName();
-                const importedValue = module.get(imported);
-                stack.getModule()?.set(local, importedValue);
-                const scopeSubscription = module.subscribe(local, (newValue, oldValue) => {
-                    if (newValue !== oldValue) {
-                        stack.getModule()?.set(local, newValue);
-                    }
-                });
-                stack.onDestroy(() => scopeSubscription.unsubscribe());
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            if (!this.specifiers) {
+                return `import '${this.source.toString()}'`;
+            }
+            const parts = [];
+            const importDefaultSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportDefaultSpecifier);
+            if (importDefaultSpecifiers?.length) {
+                parts.push(importDefaultSpecifiers[0].toString());
             }
-            else if (specifier instanceof ImportDefaultSpecifier) {
-                const defaultValue = module.get('default');
-                stack.getModule()?.set(local, defaultValue);
-                const scopeSubscription = module.subscribe('default', (newValue, oldValue) => {
-                    if (newValue !== oldValue) {
-                        stack.getModule()?.set(local, newValue);
-                    }
-                });
-                stack.onDestroy(() => scopeSubscription.unsubscribe());
+            const importNamespaceSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportNamespaceSpecifier);
+            if (importNamespaceSpecifiers?.length) {
+                parts.push(importNamespaceSpecifiers[0].toString());
             }
-            else if (specifier instanceof ImportNamespaceSpecifier) {
-                stack.getModule()?.importModule(local, module);
+            const importSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportSpecifier);
+            if (importSpecifiers?.length) {
+                const importSpecifiersString = importSpecifiers.map(importSpecifier => importSpecifier.toString()).join(',');
+                parts.push(`{ ${importSpecifiersString} }`);
             }
-        });
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        if (!this.specifiers) {
-            return `import '${this.source.toString()}'`;
-        }
-        const parts = [];
-        const importDefaultSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportDefaultSpecifier);
-        if (importDefaultSpecifiers?.length) {
-            parts.push(importDefaultSpecifiers[0].toString());
-        }
-        const importNamespaceSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportNamespaceSpecifier);
-        if (importNamespaceSpecifiers?.length) {
-            parts.push(importNamespaceSpecifiers[0].toString());
-        }
-        const importSpecifiers = this.specifiers.filter(specifier => specifier instanceof ImportSpecifier);
-        if (importSpecifiers?.length) {
-            const importSpecifiersString = importSpecifiers.map(importSpecifier => importSpecifier.toString()).join(',');
-            parts.push(`{ ${importSpecifiersString} }`);
-        }
-        return `import ${parts.join(', ')} from ${this.source.toString()}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
-    }
-    toJson() {
-        return {
-            source: this.source.toJSON(),
-            specifiers: this.specifiers?.map(specifier => specifier.toJSON()),
-            assertions: this.assertions?.map(assertion => assertion.toJSON()),
-        };
-    }
-};
-ImportDeclaration = ImportDeclaration_1 = __decorate([
-    Deserializer('ImportDeclaration'),
-    __metadata("design:paramtypes", [Literal, Array, Array, Array, Object])
-], ImportDeclaration);
-export { ImportDeclaration };
+            return `import ${parts.join(', ')} from ${this.source.toString()}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
+        }
+        toJson() {
+            return {
+                source: this.source.toJSON(),
+                specifiers: this.specifiers?.map(specifier => specifier.toJSON()),
+                assertions: this.assertions?.map(assertion => assertion.toJSON()),
+            };
+        }
+    };
+    return ImportDeclaration = _classThis_3;
+})();
 /**
  * `ImportExpression` node represents Dynamic Imports such as `import(source)`.
  * The `source` property is the importing source as similar to ImportDeclaration node,
  * but it can be an arbitrary expression node.
  * var promise = import("module-name");
  */
-let ImportExpression = ImportExpression_1 = class ImportExpression extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ImportExpression_1(deserializer(node.source), (node.attributes && deserializer(node.attributes)) || undefined, node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.source);
-        node.attributes && visitNode(node.attributes);
-    }
-    constructor(source, attributes, range, loc) {
-        super(range, loc);
-        this.source = source;
-        this.attributes = attributes;
-    }
-    getSource() {
-        return this.source;
-    }
-    set(stack) {
-        throw new Error(`ImportDeclaration.#set() has no implementation.`);
-    }
-    get(stack) {
-        let importCallOptions;
-        if (this.attributes) {
-            importCallOptions = this.attributes.get(stack);
-        }
-        const module = stack.importModule(this.source.get(), importCallOptions);
-        return Promise.resolve(module);
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        return `import(${this.source.toString()}${this.attributes ? `, ${this.attributes.toString()}` : ''})`;
-    }
-    toJson() {
-        return {
-            source: this.source.toJSON(),
-        };
-    }
-};
-ImportExpression = ImportExpression_1 = __decorate([
-    Deserializer('ImportExpression'),
-    __metadata("design:paramtypes", [Literal, Object, Array, Object])
-], ImportExpression);
-export { ImportExpression };
+export let ImportExpression = (() => {
+    let _classDecorators_4 = [Deserializer('ImportExpression')];
+    let _classDescriptor_4;
+    let _classExtraInitializers_4 = [];
+    let _classThis_4;
+    var ImportExpression = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_4 = { value: this }, _classDecorators_4, { kind: "class", name: this.name }, null, _classExtraInitializers_4);
+            ImportExpression = _classThis_4 = _classDescriptor_4.value;
+            __runInitializers(_classThis_4, _classExtraInitializers_4);
+        }
+        source;
+        attributes;
+        static fromJSON(node, deserializer) {
+            return new ImportExpression(deserializer(node.source), (node.attributes && deserializer(node.attributes)) || undefined, node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.source);
+            node.attributes && visitNode(node.attributes);
+        }
+        constructor(source, attributes, range, loc) {
+            super(range, loc);
+            this.source = source;
+            this.attributes = attributes;
+        }
+        getSource() {
+            return this.source;
+        }
+        set(stack) {
+            throw new Error(`ImportDeclaration.#set() has no implementation.`);
+        }
+        get(stack) {
+            let importCallOptions;
+            if (this.attributes) {
+                importCallOptions = this.attributes.get(stack);
+            }
+            const module = stack.importModule(this.source.get(), importCallOptions);
+            return Promise.resolve(module);
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            return `import(${this.source.toString()}${this.attributes ? `, ${this.attributes.toString()}` : ''})`;
+        }
+        toJson() {
+            return {
+                source: this.source.toJSON(),
+            };
+        }
+    };
+    return ImportExpression = _classThis_4;
+})();
 //# sourceMappingURL=import.js.map