@ibyar/expressions 0.8.6 → 1.0.0

package/api/module/export.js

@@ -31,12 +31,10 @@
  * export { import1 as name1, import2 as name2, …, nameN } from …;
  * export { default, … } from …;
  */
-var ExportSpecifier_1, ExportNamedDeclaration_1, ExportDefaultDeclaration_1, ExportAllDeclaration_1;
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { ReactiveScope } from '../../scope/scope.js';
 import { AbstractExpressionNode } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
-import { Identifier, Literal } from '../definition/values.js';
 import { ModuleSpecifier } from './common.js';
 /**
  * An exported variable binding, e.g., `{foo}` in `export {foo}` or `{bar as foo}` in `export {bar as foo}`.
@@ -52,54 +50,61 @@ import { ModuleSpecifier } from './common.js';
  * 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`.
  */
-let ExportSpecifier = ExportSpecifier_1 = class ExportSpecifier extends ModuleSpecifier {
-    static fromJSON(node, deserializer) {
-        return new ExportSpecifier_1(deserializer(node.local), deserializer(node.exported), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.local);
-        visitNode(node.exported);
-    }
-    constructor(local, exported, range, loc) {
-        super(local, range, loc);
-        this.exported = exported;
-    }
-    getExported() {
-        return this.exported;
-    }
-    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 exported = this.exported.toString();
-        if (local == exported) {
-            return local;
-        }
-        return `${local} as ${exported}`;
-    }
-    toJson() {
-        return {
-            local: this.local.toJSON(),
-            exported: this.exported.toJSON()
-        };
-    }
-};
-ExportSpecifier = ExportSpecifier_1 = __decorate([
-    Deserializer('ExportSpecifier'),
-    __metadata("design:paramtypes", [Identifier,
-        Identifier, Array, Object])
-], ExportSpecifier);
-export { ExportSpecifier };
+export let ExportSpecifier = (() => {
+    let _classDecorators = [Deserializer('ExportSpecifier')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ExportSpecifier = class extends ModuleSpecifier {
+        static {
+            __esDecorate(null, _classDescriptor = { value: this }, _classDecorators, { kind: "class", name: this.name }, null, _classExtraInitializers);
+            ExportSpecifier = _classThis = _classDescriptor.value;
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        exported;
+        static fromJSON(node, deserializer) {
+            return new ExportSpecifier(deserializer(node.local), deserializer(node.exported), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.local);
+            visitNode(node.exported);
+        }
+        constructor(local, exported, range, loc) {
+            super(local, range, loc);
+            this.exported = exported;
+        }
+        getExported() {
+            return this.exported;
+        }
+        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 exported = this.exported.toString();
+            if (local == exported) {
+                return local;
+            }
+            return `${local} as ${exported}`;
+        }
+        toJson() {
+            return {
+                local: this.local.toJSON(),
+                exported: this.exported.toJSON()
+            };
+        }
+    };
+    return ExportSpecifier = _classThis;
+})();
 /**
  * An export named declaration, e.g.,
  * `export {foo, bar};`,
@@ -108,267 +113,295 @@ export { ExportSpecifier };
  *
  * Note: Having `declaration` populated with non-empty `specifiers` or non-null `source` results in an invalid state.
  */
-let ExportNamedDeclaration = ExportNamedDeclaration_1 = class ExportNamedDeclaration extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ExportNamedDeclaration_1(node.specifiers.map(deserializer), node.declaration ? deserializer(node.declaration) : void 0, node.source ? deserializer(node.source) : void 0, node.assertions ? node.assertions.map(deserializer) : void 0, node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        node.specifiers.map(visitNode);
-        node.source && visitNode(node.source);
-        node.declaration && visitNode(node.declaration);
-        node.assertions?.forEach(visitNode);
-    }
-    constructor(specifiers, declaration, source, assertions, range, loc) {
-        super(range, loc);
-        this.specifiers = specifiers;
-        this.declaration = declaration;
-        this.source = source;
-        this.assertions = assertions;
-    }
-    getSource() {
-        return this.source;
-    }
-    getSpecifiers() {
-        return this.specifiers;
-    }
-    getDeclaration() {
-        return this.declaration;
-    }
-    getAssertions() {
-        return this.assertions;
-    }
-    set(stack) {
-        throw new Error(`ExportNamedDeclaration.#set() has no implementation.`);
-    }
-    get(stack) {
-        if (this.declaration) {
-            this.exportDeclaration(stack);
-        }
-        else if (this.source) {
-            this.exportFromSource(stack);
-        }
-        else {
-            this.exportLocal(stack);
-        }
-    }
-    exportDeclaration(stack) {
-        if (!this.declaration) {
-            return;
-        }
-        this.declaration.get(stack);
-        const declaredName = this.declaration.getDeclarationName?.();
-        if (!declaredName) {
-            throw new Error(`Name is not defined for ${this.declaration.toString()}`);
-        }
-        const value = stack.get(declaredName);
-        stack.getModule().set(declaredName, value);
-    }
-    exportFromSource(stack) {
-        if (!this.source) {
-            return;
-        }
-        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 ExportNamedDeclaration = (() => {
+    let _classDecorators_1 = [Deserializer('ExportNamedDeclaration')];
+    let _classDescriptor_1;
+    let _classExtraInitializers_1 = [];
+    let _classThis_1;
+    var ExportNamedDeclaration = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_1 = { value: this }, _classDecorators_1, { kind: "class", name: this.name }, null, _classExtraInitializers_1);
+            ExportNamedDeclaration = _classThis_1 = _classDescriptor_1.value;
+            __runInitializers(_classThis_1, _classExtraInitializers_1);
+        }
+        specifiers;
+        declaration;
+        source;
+        assertions;
+        static fromJSON(node, deserializer) {
+            return new ExportNamedDeclaration(node.specifiers.map(deserializer), node.declaration ? deserializer(node.declaration) : void 0, node.source ? deserializer(node.source) : void 0, node.assertions ? node.assertions.map(deserializer) : void 0, node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            node.specifiers.map(visitNode);
+            node.source && visitNode(node.source);
+            node.declaration && visitNode(node.declaration);
+            node.assertions?.forEach(visitNode);
+        }
+        constructor(specifiers, declaration, source, assertions, range, loc) {
+            super(range, loc);
+            this.specifiers = specifiers;
+            this.declaration = declaration;
+            this.source = source;
+            this.assertions = assertions;
+        }
+        getSource() {
+            return this.source;
+        }
+        getSpecifiers() {
+            return this.specifiers;
+        }
+        getDeclaration() {
+            return this.declaration;
+        }
+        getAssertions() {
+            return this.assertions;
+        }
+        set(stack) {
+            throw new Error(`ExportNamedDeclaration.#set() has no implementation.`);
+        }
+        get(stack) {
+            if (this.declaration) {
+                this.exportDeclaration(stack);
+            }
+            else if (this.source) {
+                this.exportFromSource(stack);
+            }
+            else {
+                this.exportLocal(stack);
             }
         }
-        const sourceModule = stack.importModule(this.source.get(), importCallOptions);
-        const localModule = stack.getModule();
-        this.specifiers.forEach(specifier => {
-            const localName = specifier.getLocal().get(stack);
-            const exportedName = specifier.getExported().get(stack);
-            const localValue = sourceModule.get(localName);
-            localModule.set(exportedName, localValue);
-            const scopeSubscription = sourceModule.subscribe(localName, (newLocalValue, oldLocalValue) => {
-                if (newLocalValue !== oldLocalValue) {
-                    localModule.set(exportedName, newLocalValue);
+        exportDeclaration(stack) {
+            if (!this.declaration) {
+                return;
+            }
+            this.declaration.get(stack);
+            const declaredName = this.declaration.getDeclarationName?.();
+            if (!declaredName) {
+                throw new Error(`Name is not defined for ${this.declaration.toString()}`);
+            }
+            const value = stack.get(declaredName);
+            stack.getModule().set(declaredName, value);
+        }
+        exportFromSource(stack) {
+            if (!this.source) {
+                return;
+            }
+            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 };
                 }
-            });
-            stack.onDestroy(() => scopeSubscription.unsubscribe());
-        });
-    }
-    exportLocal(stack, importCallOptions) {
-        const localModule = stack.getModule();
-        this.specifiers.forEach(specifier => {
-            const localName = specifier.getLocal().get(stack);
-            const exportedName = specifier.getExported().get(stack);
-            const localValue = stack.get(localName);
-            localModule.set(exportedName, localValue);
-            const scope = stack.findScope(localName);
-            if (scope instanceof ReactiveScope) {
-                const scopeSubscription = scope.subscribe(localName, (newLocalValue, oldLocalValue) => {
+            }
+            const sourceModule = stack.importModule(this.source.get(), importCallOptions);
+            const localModule = stack.getModule();
+            this.specifiers.forEach(specifier => {
+                const localName = specifier.getLocal().get(stack);
+                const exportedName = specifier.getExported().get(stack);
+                const localValue = sourceModule.get(localName);
+                localModule.set(exportedName, localValue);
+                const scopeSubscription = sourceModule.subscribe(localName, (newLocalValue, oldLocalValue) => {
                     if (newLocalValue !== oldLocalValue) {
                         localModule.set(exportedName, newLocalValue);
                     }
                 });
                 stack.onDestroy(() => scopeSubscription.unsubscribe());
+            });
+        }
+        exportLocal(stack, importCallOptions) {
+            const localModule = stack.getModule();
+            this.specifiers.forEach(specifier => {
+                const localName = specifier.getLocal().get(stack);
+                const exportedName = specifier.getExported().get(stack);
+                const localValue = stack.get(localName);
+                localModule.set(exportedName, localValue);
+                const scope = stack.findScope(localName);
+                if (scope instanceof ReactiveScope) {
+                    const scopeSubscription = scope.subscribe(localName, (newLocalValue, oldLocalValue) => {
+                        if (newLocalValue !== oldLocalValue) {
+                            localModule.set(exportedName, newLocalValue);
+                        }
+                    });
+                    stack.onDestroy(() => scopeSubscription.unsubscribe());
+                }
+            });
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            if (this.declaration) {
+                const declaration = this.declaration.toString();
+                return `export ${declaration}`;
             }
-        });
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        if (this.declaration) {
-            const declaration = this.declaration.toString();
-            return `export ${declaration}`;
-        }
-        const specifiers = this.specifiers.map(specifier => specifier.toString()).join(',');
-        let exportStr = `export {${specifiers}}`;
-        if (!this.source) {
-            return `${exportStr};`;
-        }
-        const source = this.source.toString();
-        return `${exportStr} from ${source}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
-    }
-    toJson() {
-        return {
-            specifiers: this.specifiers.map(specifier => specifier.toJSON()),
-            source: this.source?.toJSON(),
-            declaration: this.declaration?.toJSON(),
-            assertions: this.assertions?.map(assertion => assertion.toJSON()),
-        };
-    }
-};
-ExportNamedDeclaration = ExportNamedDeclaration_1 = __decorate([
-    Deserializer('ExportNamedDeclaration'),
-    __metadata("design:paramtypes", [Array, Object, Literal, Array, Array, Object])
-], ExportNamedDeclaration);
-export { ExportNamedDeclaration };
+            const specifiers = this.specifiers.map(specifier => specifier.toString()).join(',');
+            let exportStr = `export {${specifiers}}`;
+            if (!this.source) {
+                return `${exportStr};`;
+            }
+            const source = this.source.toString();
+            return `${exportStr} from ${source}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
+        }
+        toJson() {
+            return {
+                specifiers: this.specifiers.map(specifier => specifier.toJSON()),
+                source: this.source?.toJSON(),
+                declaration: this.declaration?.toJSON(),
+                assertions: this.assertions?.map(assertion => assertion.toJSON()),
+            };
+        }
+    };
+    return ExportNamedDeclaration = _classThis_1;
+})();
 /**
  * An export default declaration, e.g.,
  * `export default function () {};`
  * or `export default 1;`.
  */
-let ExportDefaultDeclaration = ExportDefaultDeclaration_1 = class ExportDefaultDeclaration extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ExportDefaultDeclaration_1(deserializer(node.declaration), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.declaration);
-    }
-    constructor(declaration, range, loc) {
-        super(range, loc);
-        this.declaration = declaration;
-    }
-    getDeclaration() {
-        return this.declaration;
-    }
-    set(stack) {
-        throw new Error(`ExportDefaultDeclaration.#set() has no implementation.`);
-    }
-    get(stack) {
-        const declaration = this.declaration.get(stack);
-        stack.getModule().set('default', declaration);
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        const declaration = this.declaration.toString();
-        return `export default ${declaration}`;
-    }
-    toJson() {
-        return {
-            declaration: this.declaration.toJSON(),
-        };
-    }
-};
-ExportDefaultDeclaration = ExportDefaultDeclaration_1 = __decorate([
-    Deserializer('ExportDefaultDeclaration'),
-    __metadata("design:paramtypes", [Object, Array, Object])
-], ExportDefaultDeclaration);
-export { ExportDefaultDeclaration };
+export let ExportDefaultDeclaration = (() => {
+    let _classDecorators_2 = [Deserializer('ExportDefaultDeclaration')];
+    let _classDescriptor_2;
+    let _classExtraInitializers_2 = [];
+    let _classThis_2;
+    var ExportDefaultDeclaration = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_2 = { value: this }, _classDecorators_2, { kind: "class", name: this.name }, null, _classExtraInitializers_2);
+            ExportDefaultDeclaration = _classThis_2 = _classDescriptor_2.value;
+            __runInitializers(_classThis_2, _classExtraInitializers_2);
+        }
+        declaration;
+        static fromJSON(node, deserializer) {
+            return new ExportDefaultDeclaration(deserializer(node.declaration), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.declaration);
+        }
+        constructor(declaration, range, loc) {
+            super(range, loc);
+            this.declaration = declaration;
+        }
+        getDeclaration() {
+            return this.declaration;
+        }
+        set(stack) {
+            throw new Error(`ExportDefaultDeclaration.#set() has no implementation.`);
+        }
+        get(stack) {
+            const declaration = this.declaration.get(stack);
+            stack.getModule().set('default', declaration);
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            const declaration = this.declaration.toString();
+            return `export default ${declaration}`;
+        }
+        toJson() {
+            return {
+                declaration: this.declaration.toJSON(),
+            };
+        }
+    };
+    return ExportDefaultDeclaration = _classThis_2;
+})();
 /**
  * An export batch declaration, e.g., `export * from "mod";`.
  */
-let ExportAllDeclaration = ExportAllDeclaration_1 = class ExportAllDeclaration extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ExportAllDeclaration_1(deserializer(node.source), node.exported ? deserializer(node.exported) : void 0, node.assertions?.map(deserializer), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.source);
-        node.exported && visitNode(node.exported);
-        node.assertions?.forEach(visitNode);
-    }
-    constructor(source, exported, assertions, range, loc) {
-        super(range, loc);
-        this.source = source;
-        this.exported = exported;
-        this.assertions = assertions;
-    }
-    getSource() {
-        return this.source;
-    }
-    getExported() {
-        return this.exported;
-    }
-    getAssertions() {
-        return this.assertions;
-    }
-    set(stack) {
-        throw new Error(`ExportDefaultDeclaration.#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 ExportAllDeclaration = (() => {
+    let _classDecorators_3 = [Deserializer('ExportAllDeclaration')];
+    let _classDescriptor_3;
+    let _classExtraInitializers_3 = [];
+    let _classThis_3;
+    var ExportAllDeclaration = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_3 = { value: this }, _classDecorators_3, { kind: "class", name: this.name }, null, _classExtraInitializers_3);
+            ExportAllDeclaration = _classThis_3 = _classDescriptor_3.value;
+            __runInitializers(_classThis_3, _classExtraInitializers_3);
+        }
+        source;
+        exported;
+        assertions;
+        static fromJSON(node, deserializer) {
+            return new ExportAllDeclaration(deserializer(node.source), node.exported ? deserializer(node.exported) : void 0, node.assertions?.map(deserializer), node.range, node.loc);
         }
-        let localModule = stack.getModule();
-        const sourceModule = stack.importModule(this.source.get(), importCallOptions);
-        if (this.exported) {
-            const exportedName = this.exported.get(stack);
-            localModule.set(exportedName, {});
-            localModule = localModule.getInnerScope(exportedName);
-        }
-        const properties = Object.keys(sourceModule.getContext());
-        properties.forEach(property => {
-            const localValue = sourceModule.get(property);
-            localModule.set(property, localValue);
-            const scopeSubscription = sourceModule.subscribe(property, (newLocalValue, oldLocalValue) => {
-                if (newLocalValue !== oldLocalValue) {
-                    localModule.set(property, newLocalValue);
+        static visit(node, visitNode) {
+            visitNode(node.source);
+            node.exported && visitNode(node.exported);
+            node.assertions?.forEach(visitNode);
+        }
+        constructor(source, exported, assertions, range, loc) {
+            super(range, loc);
+            this.source = source;
+            this.exported = exported;
+            this.assertions = assertions;
+        }
+        getSource() {
+            return this.source;
+        }
+        getExported() {
+            return this.exported;
+        }
+        getAssertions() {
+            return this.assertions;
+        }
+        set(stack) {
+            throw new Error(`ExportDefaultDeclaration.#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 };
                 }
+            }
+            let localModule = stack.getModule();
+            const sourceModule = stack.importModule(this.source.get(), importCallOptions);
+            if (this.exported) {
+                const exportedName = this.exported.get(stack);
+                localModule.set(exportedName, {});
+                localModule = localModule.getInnerScope(exportedName);
+            }
+            const properties = Object.keys(sourceModule.getContext());
+            properties.forEach(property => {
+                const localValue = sourceModule.get(property);
+                localModule.set(property, localValue);
+                const scopeSubscription = sourceModule.subscribe(property, (newLocalValue, oldLocalValue) => {
+                    if (newLocalValue !== oldLocalValue) {
+                        localModule.set(property, newLocalValue);
+                    }
+                });
+                stack.onDestroy(() => scopeSubscription.unsubscribe());
             });
-            stack.onDestroy(() => scopeSubscription.unsubscribe());
-        });
-    }
-    dependency(computed) {
-        return [];
-    }
-    dependencyPath(computed) {
-        return [];
-    }
-    toString() {
-        return `export *${this.exported ? ` as ${this.exported.toString()}` : ''} from ${this.source.toString()}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
-    }
-    toJson() {
-        return {
-            source: this.source.toJSON(),
-            exported: this.exported?.toJSON(),
-            assertions: this.assertions?.map(assertion => assertion.toJSON()),
-        };
-    }
-};
-ExportAllDeclaration = ExportAllDeclaration_1 = __decorate([
-    Deserializer('ExportAllDeclaration'),
-    __metadata("design:paramtypes", [Literal,
-        Identifier, Array, Array, Object])
-], ExportAllDeclaration);
-export { ExportAllDeclaration };
+        }
+        dependency(computed) {
+            return [];
+        }
+        dependencyPath(computed) {
+            return [];
+        }
+        toString() {
+            return `export *${this.exported ? ` as ${this.exported.toString()}` : ''} from ${this.source.toString()}${this.assertions ? ` assert { ${this.assertions.map(assertion => assertion.toString()).join(', ')} }` : ''};`;
+        }
+        toJson() {
+            return {
+                source: this.source.toJSON(),
+                exported: this.exported?.toJSON(),
+                assertions: this.assertions?.map(assertion => assertion.toJSON()),
+            };
+        }
+    };
+    return ExportAllDeclaration = _classThis_3;
+})();
 //# sourceMappingURL=export.js.map