molstar 3.0.1 → 3.0.2

package/lib/commonjs/mol-script/script/mol-script/parser.js

@@ -0,0 +1,162 @@
+"use strict";
+// /**
+//  * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+//  *
+//  * @author David Sehnal <david.sehnal@gmail.com>
+//  */
+// import { MonadicParser as P } from 'mol-util/monadic-parser'
+// import Expression from '../../language/expression'
+// import B from '../../language/builder'
+// export function parseMolScript(input: string) {
+//     return Language.parse(input);
+// }
+// namespace Language {
+//     type AST = ASTNode.Expression[]
+//     namespace ASTNode {
+//         export type Expression = Str | Symb | List | Comment
+//         export interface Str {
+//             kind: 'string',
+//             value: string
+//         }
+//         export interface Symb {
+//             kind: 'symbol',
+//             value: string
+//         }
+//         export interface List {
+//             kind: 'list',
+//             bracket: '(' | '[' | '{',
+//             nodes: Expression[]
+//         }
+//         export interface Comment {
+//             kind: 'comment',
+//             value: string
+//         }
+//         export function str(value: string): Str { return { kind: 'string', value }; }
+//         export function symb(value: string): Symb { return { kind: 'symbol', value }; }
+//         export function list(bracket: '(' | '[' | '{', nodes: Expression[]): List { return { kind: 'list', bracket, nodes }; }
+//         export function comment(value: string): Comment { return { kind: 'comment', value } }
+//     }
+//     const ws = P.regexp(/[\n\r\s]*/);
+//     const Expr: P<ASTNode.Expression> = P.lazy(() => (P.alt(Str, List, Symb, Comment).trim(ws)));
+//     const Str = P.takeWhile(c => c !== '`').trim('`').map(ASTNode.str);
+//     const Symb = P.regexp(/[^()\[\]{};`,\n\r\s]+/).map(ASTNode.symb);
+//     const Comment = P.regexp(/\s*;+([^\n\r]*)\n/, 1).map(ASTNode.comment);
+//     const Args = Expr.many();
+//     const List1 = Args.wrap('(', ')').map(args => ASTNode.list('(', args));
+//     const List2 = Args.wrap('[', ']').map(args => ASTNode.list('[', args));
+//     const List3 = Args.wrap('{', '}').map(args => ASTNode.list('{', args));
+//     const List = P.alt(List1, List2, List3);
+//     const Expressions: P<AST> = Expr.many();
+//     function getAST(input: string) { return Expressions.tryParse(input); }
+//     function visitExpr(expr: ASTNode.Expression): Expression {
+//         switch (expr.kind) {
+//             case 'string': return expr.value;
+//             case 'symbol': {
+//                 const value = expr.value;
+//                 if (value.length > 1) {
+//                     const fst = value.charAt(0);
+//                     switch (fst) {
+//                         case '.': return B.atomName(value.substr(1));
+//                         case '_': return B.struct.type.elementSymbol([value.substr(1)]);
+//                     }
+//                 }
+//                 if (value === 'true') return true;
+//                 if (value === 'false') return false;
+//                 if (isNumber(value)) return +value;
+//                 return Expression.Symbol(value);
+//             }
+//             case 'list': {
+//                 switch (expr.bracket) {
+//                     case '[': return B.core.type.list(withoutComments(expr.nodes).map(visitExpr));
+//                     case '{': return B.core.type.set(withoutComments(expr.nodes).map(visitExpr));
+//                     case '(': {
+//                         const head = visitExpr(expr.nodes[0]);
+//                         return Expression.Apply(head, getArgs(expr.nodes));
+//                     }
+//                 }
+//                 return 0 as any;
+//             }
+//             default: {
+//                 throw new Error('should not happen');
+//             }
+//         }
+//     }
+//     function getArgs(nodes: ASTNode.Expression[]): Expression.Arguments | undefined {
+//         if (nodes.length <= 1) return void 0;
+//         if (!hasNamedArgs(nodes)) {
+//             const args: Expression[] = [];
+//             for (let i = 1, _i = nodes.length; i < _i; i++) {
+//                 const n = nodes[i];
+//                 if (n.kind === 'comment') continue;
+//                 args[args.length] = visitExpr(n);
+//             }
+//             return args;
+//         }
+//         const args: { [name: string]: Expression } = {};
+//         let allNumeric = true;
+//         let pos = 0;
+//         for (let i = 1, _i = nodes.length; i < _i; i++) {
+//             const n = nodes[i];
+//             if (n.kind === 'comment') continue;
+//             if (n.kind === 'symbol' && n.value.length > 1 && n.value.charAt(0) === ':') {
+//                 const name = n.value.substr(1);
+//                 ++i;
+//                 while (i < _i && nodes[i].kind === 'comment') { i++; }
+//                 if (i >= _i) throw new Error(`There must be a value foolowed a named arg ':${name}'.`);
+//                 args[name] = visitExpr(nodes[i]);
+//                 if (isNaN(+name)) allNumeric = false;
+//             } else {
+//                 args[pos++] = visitExpr(n);
+//             }
+//         }
+//         if (allNumeric) {
+//             const keys = Object.keys(args).map(a => +a).sort((a, b) => a - b);
+//             let isArray = true;
+//             for (let i = 0, _i = keys.length; i < _i; i++) {
+//                 if (keys[i] !== i) {
+//                     isArray = false;
+//                     break;
+//                 }
+//             }
+//             if (isArray) {
+//                 const arrayArgs: Expression[] = [];
+//                 for (let i = 0, _i = keys.length; i < _i; i++) {
+//                     arrayArgs[i] = args[i];
+//                 }
+//                 return arrayArgs;
+//             }
+//         }
+//         return args;
+//     }
+//     function hasNamedArgs(nodes: ASTNode.Expression[]) {
+//         for (let i = 1, _i = nodes.length; i < _i; i++) {
+//             const n = nodes[i];
+//             if (n.kind === 'symbol' && n.value.length > 1 && n.value.charAt(0) === ':') return true;
+//         }
+//         return false;
+//     }
+//     function withoutComments(nodes: ASTNode.Expression[]) {
+//         let hasComment = false;
+//         for (let i = 0, _i = nodes.length; i < _i; i++) {
+//             if (nodes[i].kind === 'comment') {
+//                 hasComment = true;
+//                 break;
+//             }
+//         }
+//         if (!hasComment) return nodes;
+//         return nodes.filter(n => n.kind !== 'comment');
+//     }
+//     function isNumber(value: string) {
+//         return /-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/.test(value);
+//     }
+//     export function parse(input: string): Expression[] {
+//         const ast = getAST(input);
+//         const ret: Expression[] = [];
+//         for (const expr of ast) {
+//             if (expr.kind === 'comment') continue;
+//             ret[ret.length] = visitExpr(expr);
+//         }
+//         return ret;
+//     }
+// }
+//# sourceMappingURL=parser.js.map

package/lib/commonjs/mol-script/script/mol-script/script-macro.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2018-2019 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export declare function getPositionalArgs(args: any): any[];
+export declare function tryGetArg(args: any, name: string | number, defaultValue?: any): any;
+export declare function pickArgs(args: any, ...names: string[]): any;
+export declare function aggregate(property: any, fn: any, initial?: any): import("../../language/expression").Expression;

package/lib/commonjs/mol-script/script/mol-script/script-macro.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2019 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregate = exports.pickArgs = exports.tryGetArg = exports.getPositionalArgs = void 0;
+var builder_1 = require("../../language/builder");
+function getPositionalArgs(args) {
+    return Object.keys(args)
+        .filter(function (k) { return !isNaN(k); })
+        .map(function (k) { return +k; })
+        .sort(function (a, b) { return a - b; })
+        .map(function (k) { return args[k]; });
+}
+exports.getPositionalArgs = getPositionalArgs;
+function tryGetArg(args, name, defaultValue) {
+    return (args && args[name] !== void 0) ? args[name] : defaultValue;
+}
+exports.tryGetArg = tryGetArg;
+function pickArgs(args) {
+    var names = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        names[_i - 1] = arguments[_i];
+    }
+    var ret = Object.create(null);
+    var count = 0;
+    for (var _a = 0, _b = Object.keys(args); _a < _b.length; _a++) {
+        var k = _b[_a];
+        if (names.indexOf(k) >= 0) {
+            ret[k] = args[k];
+            count++;
+        }
+    }
+    return count ? ret : void 0;
+}
+exports.pickArgs = pickArgs;
+function aggregate(property, fn, initial) {
+    return builder_1.MolScriptBuilder.struct.atomSet.reduce({
+        initial: initial !== void 0 ? initial : property,
+        value: fn([builder_1.MolScriptBuilder.struct.slot.elementSetReduce(), property])
+    });
+}
+exports.aggregate = aggregate;
+//# sourceMappingURL=script-macro.js.map

package/lib/commonjs/mol-script/script/mol-script/symbols.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { Expression } from '../../language/expression';
+import { MSymbol } from '../../language/symbol';
+export declare type MolScriptSymbol = {
+    kind: 'alias';
+    aliases: string[];
+    symbol: MSymbol;
+} | {
+    kind: 'macro';
+    aliases: string[];
+    symbol: MSymbol;
+    translate: (args: any) => Expression;
+};
+export declare function isMolScriptSymbol(x: any): x is MolScriptSymbol;
+export declare const SymbolTable: ((string | MolScriptSymbol)[] | (string | (string | MolScriptSymbol)[])[])[];
+export declare const MolScriptSymbols: MolScriptSymbol[];
+export declare const Constants: string[];
+export declare const NamedArgs: string[];
+export declare const SymbolMap: {
+    [id: string]: MolScriptSymbol | undefined;
+};
+export declare const SymbolList: [string, MolScriptSymbol][];
+export declare function transpileMolScript(expr: Expression): Expression;

package/lib/commonjs/mol-script/script/mol-script/symbols.js

@@ -0,0 +1,370 @@
+"use strict";
+/**
+ * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transpileMolScript = exports.SymbolList = exports.SymbolMap = exports.NamedArgs = exports.Constants = exports.MolScriptSymbols = exports.SymbolTable = exports.isMolScriptSymbol = void 0;
+var tslib_1 = require("tslib");
+var generic_1 = require("../../../mol-data/generic");
+var expression_1 = require("../../language/expression");
+var symbol_1 = require("../../language/symbol");
+var symbol_table_1 = require("../../language/symbol-table");
+var type_1 = require("../../language/type");
+var structure_query_1 = require("../../language/symbol-table/structure-query");
+var builder_1 = require("../../language/builder");
+var script_macro_1 = require("./script-macro");
+function Alias(symbol) {
+    var aliases = [];
+    for (var _a = 1; _a < arguments.length; _a++) {
+        aliases[_a - 1] = arguments[_a];
+    }
+    return { kind: 'alias', aliases: aliases, symbol: symbol };
+}
+function Macro(symbol, translate) {
+    var aliases = [];
+    for (var _a = 2; _a < arguments.length; _a++) {
+        aliases[_a - 2] = arguments[_a];
+    }
+    symbol.info.namespace = 'molscript-macro';
+    symbol.id = "molscript-macro.".concat(symbol.info.name);
+    return { kind: 'macro', symbol: symbol, translate: translate, aliases: (0, tslib_1.__spreadArray)([symbol.info.name], aliases, true) };
+}
+function isMolScriptSymbol(x) {
+    return x.kind === 'alias' || x.kind === 'macro';
+}
+exports.isMolScriptSymbol = isMolScriptSymbol;
+exports.SymbolTable = [
+    [
+        'Core symbols',
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.bool, 'bool'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.num, 'num'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.str, 'str'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.regex, 'regex'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.list, 'list'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.set, 'set'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.type.compositeKey, 'composite-key'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.logic.not, 'not'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.logic.and, 'and'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.logic.or, 'or'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.ctrl.if, 'if'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.ctrl.fn, 'fn'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.ctrl.eval, 'eval'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.add, 'add', '+'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.sub, 'sub', '-'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.mult, 'mult', '*'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.div, 'div', '/'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.pow, 'pow', '**'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.mod, 'mod'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.min, 'min'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.max, 'max'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.floor, 'floor'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.ceil, 'ceil'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.roundInt, 'round'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.abs, 'abs'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.sqrt, 'sqrt'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.cbrt, 'cbrt'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.sin, 'sin'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.cos, 'cos'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.tan, 'tan'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.asin, 'asin'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.acos, 'acos'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.atan, 'atan'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.sinh, 'sinh'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.cosh, 'cosh'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.tanh, 'tanh'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.exp, 'exp'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.log, 'log'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.log10, 'log10'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.math.atan2, 'atan2'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.eq, 'eq', '='),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.neq, 'neq', '!='),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.lt, 'lt', '<'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.lte, 'lte', '<='),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.gr, 'gr', '>'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.gre, 'gre', '>='),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.rel.inRange, 'in-range'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.str.concat, 'concat'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.str.match, 'regex.match'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.list.getAt, 'list.get'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.set.has, 'set.has'),
+        Alias(symbol_table_1.MolScriptSymbolTable.core.set.isSubset, 'set.subset'),
+    ],
+    [
+        'Structure',
+        [
+            'Types',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.type.entityType, 'ent-type'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.type.authResidueId, 'auth-resid'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.type.labelResidueId, 'label-resid'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.type.ringFingerprint, 'ringfp'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.type.bondFlags, 'bond-flags'),
+        ],
+        [
+            'Slots',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.slot.elementSetReduce, 'atom.set.reduce.value'),
+        ],
+        [
+            'Generators',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.atomGroups, 'sel.atom.atom-groups'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.queryInSelection, 'sel.atom.query-in-selection'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.rings, 'sel.atom.rings'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.empty, 'sel.atom.empty'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.all, 'sel.atom.all'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.generator.bondedAtomicPairs, 'sel.atom.bonded-pairs'),
+            Macro((0, symbol_1.MSymbol)('sel.atom.atoms', symbol_1.Arguments.Dictionary({
+                0: (0, symbol_1.Argument)(type_1.Type.Bool, { isOptional: true, defaultValue: true, description: 'Test applied to each atom.' })
+            }), structure_query_1.Types.ElementSelection, 'A selection of singleton atom sets.'), function (args) { return builder_1.MolScriptBuilder.struct.generator.atomGroups({ 'atom-test': (0, script_macro_1.tryGetArg)(args, 0, true) }); }),
+            Macro((0, symbol_1.MSymbol)('sel.atom.res', symbol_1.Arguments.Dictionary({
+                0: (0, symbol_1.Argument)(type_1.Type.Bool, { isOptional: true, defaultValue: true, description: 'Test applied to the 1st atom of each residue.' })
+            }), structure_query_1.Types.ElementSelection, 'A selection of atom sets grouped by residue.'), function (args) { return builder_1.MolScriptBuilder.struct.generator.atomGroups({
+                'residue-test': (0, script_macro_1.tryGetArg)(args, 0, true),
+                'group-by': builder_1.MolScriptBuilder.ammp('residueKey')
+            }); }),
+            Macro((0, symbol_1.MSymbol)('sel.atom.chains', symbol_1.Arguments.Dictionary({
+                0: (0, symbol_1.Argument)(type_1.Type.Bool, { isOptional: true, defaultValue: true, description: 'Test applied to the 1st atom of each chain.' })
+            }), structure_query_1.Types.ElementSelection, 'A selection of atom sets grouped by chain.'), function (args) { return builder_1.MolScriptBuilder.struct.generator.atomGroups({
+                'chain-test': (0, script_macro_1.tryGetArg)(args, 0, true),
+                'group-by': builder_1.MolScriptBuilder.ammp('chainKey')
+            }); }),
+        ],
+        [
+            'Modifiers',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.queryEach, 'sel.atom.query-each'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.intersectBy, 'sel.atom.intersect-by'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.exceptBy, 'sel.atom.except-by'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.unionBy, 'sel.atom.union-by'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.union, 'sel.atom.union'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.cluster, 'sel.atom.cluster'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.includeSurroundings, 'sel.atom.include-surroundings'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.surroundingLigands, 'sel.atom.surrounding-ligands'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.includeConnected, 'sel.atom.include-connected'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.modifier.expandProperty, 'sel.atom.expand-property'),
+            // Macro(MSymbol('sel.atom.around', Arguments.Dictionary({
+            //     0: Argument(Type.Bool, { isOptional: true, defaultValue: true, description: 'Test applied to the 1st atom of each chain.' })
+            // }), Struct.Types.ElementSelection, 'A selection of singleton atom sets with centers within "radius" of the center of any atom in the given selection.'),
+            // args => B.struct.modifier.exceptBy({
+            //     '0': B.struct.filter.within({
+            //         '0': B.struct.generator.atomGroups(), target: M.tryGetArg(args, 0), 'max-radius': M.tryGetArg(args, 'radius')
+            //     }),
+            //     by: M.tryGetArg(args, 0)
+            // }))
+        ],
+        [
+            'Filters',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.pick, 'sel.atom.pick'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.first, 'sel.atom.first'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.withSameAtomProperties, 'sel.atom.with-same-atom-properties'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.intersectedBy, 'sel.atom.intersected-by'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.within, 'sel.atom.within'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.filter.isConnectedTo, 'sel.atom.is-connected-to'),
+        ],
+        [
+            'Combinators',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.combinator.intersect, 'sel.atom.intersect'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.combinator.merge, 'sel.atom.merge'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.combinator.distanceCluster, 'sel.atom.dist-cluster'),
+        ],
+        [
+            'Atom Set Properties',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomSet.atomCount, 'atom.set.atom-count'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomSet.countQuery, 'atom.set.count-query'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomSet.reduce, 'atom.set.reduce'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomSet.propertySet, 'atom.set.property'),
+            // Macro(MSymbol('atom.set.max', Arguments.Dictionary({
+            //     0: Argument(Type.Num, { description: 'Numeric atom property.'})
+            // }), Type.Num, 'Maximum of the given property in the current atom set.'),
+            // args => M.aggregate(M.tryGetArg(args, 0), B.core.math.max)),
+            // Macro(MSymbol('atom.set.sum', Arguments.Dictionary({
+            //     0: Argument(Type.Num, { description: 'Numeric atom property.'})
+            // }), Type.Num, 'Sum of the given property in the current atom set.'),
+            // args => M.aggregate(M.tryGetArg(args, 0), B.core.math.add, 0)),
+            // Macro(MSymbol('atom.set.avg', Arguments.Dictionary({
+            //     0: Argument(Type.Num, { description: 'Numeric atom property.'})
+            // }), Type.Num, 'Average of the given property in the current atom set.'),
+            // args => B.core.math.div([ M.aggregate(M.tryGetArg(args, 0), B.core.math.add, 0), B.struct.atomSet.atomCount() ])),
+            // Macro(MSymbol('atom.set.min', Arguments.Dictionary({
+            //     0: Argument(Type.Num, { description: 'Numeric atom property.'})
+            // }), Type.Num, 'Minimum of the given property in the current atom set.'),
+            // args => M.aggregate(M.tryGetArg(args, 0), B.core.math.min))
+        ],
+        [
+            'Atom Properties',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.elementSymbol, 'atom.el'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.vdw, 'atom.vdw'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.mass, 'atom.mass'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.atomicNumber, 'atom.atomic-number'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.x, 'atom.x'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.y, 'atom.y'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.z, 'atom.z'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.sourceIndex, 'atom.src-index'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.operatorName, 'atom.op-name'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.modelIndex, 'atom.model-index'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.modelLabel, 'atom.model-label'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.atomKey, 'atom.key'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.core.bondCount, 'atom.bond-count'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.topology.connectedComponentKey, 'atom.key.molecule'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.authResidueId, 'atom.auth-resid'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.labelResidueId, 'atom.label-resid'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.residueKey, 'atom.key.res'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.chainKey, 'atom.key.chain'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.entityKey, 'atom.key.entity'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.isHet, 'atom.is-het'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.id, 'atom.id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_atom_id, 'atom.label_atom_id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_alt_id, 'atom.label_alt_id', 'atom.altloc'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_comp_id, 'atom.label_comp_id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_asym_id, 'atom.label_asym_id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_entity_id, 'atom.label_entity_id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.label_seq_id, 'atom.label_seq_id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.auth_atom_id, 'atom.auth_atom_id', 'atom.name'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.auth_comp_id, 'atom.auth_comp_id', 'atom.resname'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.auth_asym_id, 'atom.auth_asym_id', 'atom.chain'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.auth_seq_id, 'atom.auth_seq_id', 'atom.resno'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.pdbx_PDB_ins_code, 'atom.pdbx_PDB_ins_code', 'atom.inscode'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.pdbx_formal_charge, 'atom.pdbx_formal_charge'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.occupancy, 'atom.occupancy'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.B_iso_or_equiv, 'atom.B_iso_or_equiv', 'atom.bfactor'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.entityType, 'atom.entity-type'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.entitySubtype, 'atom.entity-subtype'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.entityPrdId, 'atom.entity-prd-id'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.entityDescription, 'atom.entity-description'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.objectPrimitive, 'atom.object-primitive'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.chemCompType, 'atom.chem-comp-type'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.secondaryStructureKey, 'atom.key.sec-struct'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.isModified, 'atom.is-modified'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.atomProperty.macromolecular.modifiedParentName, 'atom.modified-parent'),
+            // Macro(MSymbol('atom.sec-struct.is', Arguments.List(Struct.Types.SecondaryStructureFlag), Type.Bool,
+            //     `Test if the current atom is part of an secondary structure. Optionally specify allowed sec. struct. types: ${Type.oneOfValues(Struct.Types.SecondaryStructureFlag).join(', ')}`),
+            // args => B.core.flags.hasAny([B.struct.atomProperty.macromolecular.secondaryStructureFlags(), B.struct.type.secondaryStructureFlags(args)])),
+        ],
+        [
+            'Bond Properties',
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.bondProperty.order, 'bond.order'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.bondProperty.length, 'bond.length'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.bondProperty.atomA, 'bond.atom-a'),
+            Alias(symbol_table_1.MolScriptSymbolTable.structureQuery.bondProperty.atomB, 'bond.atom-b'),
+            Macro((0, symbol_1.MSymbol)('bond.is', symbol_1.Arguments.List(structure_query_1.Types.BondFlag), type_1.Type.Bool, "Test if the current bond has at least one (or all if partial = false) of the specified flags: ".concat(type_1.Type.oneOfValues(structure_query_1.Types.BondFlag).join(', '))), function (args) { return builder_1.MolScriptBuilder.core.flags.hasAny([builder_1.MolScriptBuilder.struct.bondProperty.flags(), builder_1.MolScriptBuilder.struct.type.bondFlags((0, script_macro_1.getPositionalArgs)(args))]); }),
+        ]
+    ]
+];
+var list = [];
+function makeList(xs) {
+    for (var _a = 0, xs_1 = xs; _a < xs_1.length; _a++) {
+        var x = xs_1[_a];
+        if (isMolScriptSymbol(x))
+            list.push(x);
+        else if (x instanceof Array)
+            makeList(x);
+    }
+}
+makeList(exports.SymbolTable);
+var normalized = (function () {
+    var symbolList = [];
+    var symbolMap = Object.create(null);
+    var namedArgs = generic_1.UniqueArray.create();
+    var constants = generic_1.UniqueArray.create();
+    for (var _a = 0, list_1 = list; _a < list_1.length; _a++) {
+        var s = list_1[_a];
+        for (var _b = 0, _c = s.aliases; _b < _c.length; _b++) {
+            var a = _c[_b];
+            symbolList.push([a, s]);
+            if (symbolMap[a])
+                throw new Error("Alias '".concat(a, "' already in use."));
+            symbolMap[a] = s;
+        }
+        var args = s.symbol.args;
+        if (args.kind !== 'dictionary') {
+            if (args.type.kind === 'oneof') {
+                type_1.Type.oneOfValues(args.type).forEach(function (v) { return generic_1.UniqueArray.add(constants, v, v); });
+            }
+            continue;
+        }
+        for (var _d = 0, _e = Object.keys(args.map); _d < _e.length; _d++) {
+            var a = _e[_d];
+            if (isNaN(a))
+                generic_1.UniqueArray.add(namedArgs, a, a);
+            var arg = (args.map[a]);
+            if (arg.type.kind === 'oneof') {
+                type_1.Type.oneOfValues(arg.type).forEach(function (v) { return generic_1.UniqueArray.add(constants, v, v); });
+            }
+        }
+    }
+    return { symbolList: symbolList, symbolMap: symbolMap, namedArgs: namedArgs.array, constants: constants.array };
+})();
+exports.MolScriptSymbols = list;
+exports.Constants = normalized.constants;
+exports.NamedArgs = normalized.namedArgs;
+exports.SymbolMap = normalized.symbolMap;
+exports.SymbolList = normalized.symbolList;
+function substSymbols(expr) {
+    if (expression_1.Expression.isLiteral(expr)) {
+        return expr;
+    }
+    if (expression_1.Expression.isSymbol(expr)) {
+        if (!exports.SymbolMap[expr.name])
+            return expr;
+        var s = exports.SymbolMap[expr.name];
+        if (s.kind === 'alias')
+            return expression_1.Expression.Symbol(exports.SymbolMap[expr.name].symbol.id);
+        throw s.translate([]);
+    }
+    var isMacro = expression_1.Expression.isSymbol(expr.head) && !!exports.SymbolMap[expr.head.name] && exports.SymbolMap[expr.head.name].kind === 'macro';
+    var head = isMacro ? expr.head : substSymbols(expr.head);
+    var headChanged = head !== expr.head;
+    if (!expr.args) {
+        if (isMacro)
+            return substSymbols(expr.head); // TODO: is this correct?
+        return headChanged ? expression_1.Expression.Apply(head) : expr;
+    }
+    var argsChanged = false;
+    var newArgs;
+    if (expression_1.Expression.isArgumentsArray(expr.args)) {
+        newArgs = [];
+        for (var i = 0, _i = expr.args.length; i < _i; i++) {
+            var oldArg = expr.args[i];
+            var newArg = substSymbols(oldArg);
+            if (oldArg !== newArg)
+                argsChanged = true;
+            newArgs[newArgs.length] = newArg;
+        }
+        if (!argsChanged)
+            newArgs = expr.args;
+        if (!isMacro && !headChanged && !argsChanged)
+            return expr;
+    }
+    else {
+        newArgs = {};
+        for (var _a = 0, _b = Object.keys(expr.args); _a < _b.length; _a++) {
+            var key = _b[_a];
+            var oldArg = expr.args[key];
+            var newArg = substSymbols(oldArg);
+            if (oldArg !== newArg)
+                argsChanged = true;
+            newArgs[key] = newArg;
+        }
+        if (!isMacro && !headChanged && !argsChanged)
+            return expr;
+        if (!argsChanged)
+            newArgs = expr.args;
+    }
+    if (isMacro) {
+        var macro = exports.SymbolMap[expr.head.name];
+        if (macro.kind !== 'macro')
+            return expression_1.Expression.Apply(head, newArgs);
+        var ret = macro.translate(newArgs);
+        return ret;
+    }
+    return expression_1.Expression.Apply(head, newArgs);
+}
+function transpileMolScript(expr) {
+    return substSymbols(expr);
+}
+exports.transpileMolScript = transpileMolScript;
+// const sortedSymbols = SymbolList.map(s => s[0]).sort((a, b) => {
+//     if (a.length === b.length) return (a < b) as any;
+//     return a.length - b.length;
+// });
+// export default [...sortedSymbols, ...NamedArgs.map(a => ':' + a), ...Constants];
+//# sourceMappingURL=symbols.js.map

package/lib/commonjs/mol-script/script/parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexanderose@weirdbyte.de>
+ */
+import { Expression } from '../language/expression';
+export declare type Parser = (source: string) => Expression;

package/lib/commonjs/mol-script/script/parser.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexanderose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=parser.js.map