diff --git a/src/mol-plugin-state/transforms/model.ts b/src/mol-plugin-state/transforms/model.ts
index b9773c5a6a198672cfda9c7dbaa0ea1158435941..b4b24ff137cb7cab29262f9fba96234daaa7339a 100644
--- a/src/mol-plugin-state/transforms/model.ts
+++ b/src/mol-plugin-state/transforms/model.ts
@@ -786,7 +786,7 @@ const StructureSelectionFromScript = PluginStateTransform.BuiltIn({
     from: SO.Molecule.Structure,
     to: SO.Molecule.Structure,
     params: () => ({
-        script: PD.Script({ language: 'vmd', expression: 'all' }),
+        script: PD.Script({ language: 'pymol', expression: 'all' }),
         label: PD.Optional(PD.Text(''))
     })
 })({
diff --git a/src/mol-script/script.ts b/src/mol-script/script.ts
index e29ea271e8753fd4229b18fcffaddd0ea1fd4a95..866d5f1efa36a27d188efd1a13b760ae46bc100a 100644
--- a/src/mol-script/script.ts
+++ b/src/mol-script/script.ts
@@ -30,7 +30,7 @@ function Script(expression: string = "(sel.atom.all)", language: Script.Language
 }
 
 namespace Script {
-    export type Language = 'mol-script' | 'pymol' | 'vmd' | 'jmol | rasmol' 
+    export type Language = 'mol-script' | 'pymol' | 'vmd' | 'jmol' | 'rasmol' 
 
     export function is(x: any): x is Script {
         return !!x && typeof (x as Script).expression === 'string' && !!(x as Script).language;
diff --git a/src/mol-script/transpilers/all.ts b/src/mol-script/transpilers/all.ts
index 0cfb83723392b415cd236c826be74d5ce5cec505..1af141305a748ab7895f19a0690a4ebf9ee75f46 100644
--- a/src/mol-script/transpilers/all.ts
+++ b/src/mol-script/transpilers/all.ts
@@ -9,7 +9,7 @@ import jmol from './jmol/parser'
 //import molQLscript from './molql-script/parser'
 import pymol from './pymol/parser'
 import vmd from './vmd/parser'
-import ramol from './rasmol/parser'
+import rasmol from './rasmol/parser'
 
 export default {
     pymol,
diff --git a/src/mol-script/transpilers/pymol/keywords.ts b/src/mol-script/transpilers/pymol/keywords.ts
index 92d2b99aadcafeb3451c02ed7e8bc1674f867cd4..fc049dfbe1fff5a1b1d866febf5d68fd222708b9 100644
--- a/src/mol-script/transpilers/pymol/keywords.ts
+++ b/src/mol-script/transpilers/pymol/keywords.ts
@@ -65,7 +65,6 @@ export const keywords: KeywordDict = {
     },
     sidechain: {
         '@desc': 'Polymer non-backbone atoms (new in PyMOL 1.6.1)',
-        abbr: ['sc.']
     },
     present: {
         '@desc': 'All atoms with defined coordinates in the current state (used in creating movies)',
@@ -203,77 +202,31 @@ export const keywords: KeywordDict = {
     },
     backbone: {
         '@desc': 'the C, N, CA, and O atoms of a protein and the equivalent atoms in a nucleic acid.',
-        map: () => backboneExpr()
-    },
-    protein: {
-        '@desc': 'protein',
+        map: () => B.struct.generator.atomGroups({
+            'atom-test': B.core.set.has([
+                B.core.type.set(Backbone.protein.concat(ResDict.protein)),
+		B.ammp('label_atom_id')	
+	    ])
+	}),
+    },	    
+    proteinxxxxxx: {
+        '@desc': 'protein................',
 	abbr: ['polymer.protein'],
         map: () => B.struct.generator.atomGroups({
             'residue-test': B.core.set.has([
                 B.core.type.set(ResDict.protein),
                 B.ammp('label_comp_id')
             ])
+	})
+    },
+    nucleicxxxxx: {
+	'@desc': 'protein................',
+	abbr: ['polymer.nucleic'],
+        map: () => B.struct.generator.atomGroups({
+            'residue-test': B.core.set.has([
+                B.core.type.set(ResDict.nucleic),
+                B.ammp('label_comp_id')
+            ])
         })
-    }
+    }				   
 };
-
-function backboneExpr() {
-    return B.struct.combinator.merge([
-        B.struct.generator.queryInSelection({
-            0: proteinExpr(),
-            query: B.struct.generator.atomGroups({
-                'atom-test': B.core.set.has([
-                    h.atomNameSet(Backbone.protein),
-                    B.ammp('label_atom_id')
-                ])
-            })
-        }),
-        B.struct.generator.queryInSelection({
-            0: nucleicExpr(),
-            query: B.struct.generator.atomGroups({
-                'atom-test': B.core.set.has([
-                    h.atomNameSet(Backbone.nucleic),
-                    B.ammp('label_atom_id')
-                ])
-            })
-        })
-    ]);
-}
-
-function proteinExpr() {
-    return B.struct.filter.pick({
-        0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-        }),
-        test: B.core.set.isSubset([
-            h.atomNameSet(['C', 'N', 'CA', 'O']),
-            B.ammpSet('label_atom_id')
-        ])
-    });
-}
-
-function nucleicExpr() {
-    return B.struct.filter.pick({
-        0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-        }),
-        test: B.core.logic.and([
-            B.core.set.isSubset([
-                // B.core.type.set([ 'P', 'O1P', 'O2P' ]),
-                h.atomNameSet(['P']),
-                B.ammpSet('label_atom_id')
-            ]),
-            B.core.logic.or([
-                B.core.set.isSubset([
-                    h.atomNameSet(["O3'", "C3'", "C4'", "C5'", "O5'"]),
-                    B.ammpSet('label_atom_id')
-                ]),
-                B.core.set.isSubset([
-                    h.atomNameSet(['O3*', 'C3*', 'C4*', 'C5*', 'O5*']),
-                    B.ammpSet('label_atom_id')
-                ])
-            ])
-        ])
-    });
-}
-
diff --git a/src/mol-script/transpilers/pymol/parser.ts b/src/mol-script/transpilers/pymol/parser.ts
index 1a15f6df70fad97870b0985d4386118de366646d..2b75afbe615c5db67b91829547ed93bc3f01a1b5 100644
--- a/src/mol-script/transpilers/pymol/parser.ts
+++ b/src/mol-script/transpilers/pymol/parser.ts
@@ -59,11 +59,11 @@ const lang = P.MonadicParser.createLanguage({
 
     Expression: function (r : any) {
         return P.MonadicParser.alt(
+	    r.Keywords,
             r.AtomSelectionMacro.map(atomSelectionQuery),
             r.NamedAtomProperties,
             r.Pepseq,
             r.Rep,
-            r.Keywords,
             r.Object
         );
     },
diff --git a/src/mol-script/transpilers/pymol/properties.ts b/src/mol-script/transpilers/pymol/properties.ts
index ddc2fdf8456e25d6788b71019c6c04b03b8094e1..3cc47832a893b21872dc2829847065530441ef5c 100644
--- a/src/mol-script/transpilers/pymol/properties.ts
+++ b/src/mol-script/transpilers/pymol/properties.ts
@@ -10,7 +10,7 @@ const B = MolScriptBuilder;
 import { PropertyDict } from '../types';
 
 const reFloat = /[-+]?[0-9]*\.?[0-9]+/;
-const rePosInt = /[0-9]+/;
+//const rePosInt = /[0-9]+/;
 
 function atomNameListMap(x: string) { return x.split('+').map(B.atomName); }
 function listMap(x: string) { return x.split('+').map(x => x.replace(/^["']|["']$/g, '')); }
@@ -105,15 +105,14 @@ export const properties: PropertyDict = {
     id: {
         '@desc': 'external-index-number a single integer',
         '@examples': ['id 23'],
-        abbr: [], regex: rePosInt, map: x => parseInt(x),
+	regex: /[0-9+-]+/, map: listOrRangeMap,
         level: 'atom-test', property: B.ammp('id')
     },
     index: {
         '@desc': 'internal-index-number a single integer',
         '@examples': ['index 11'],
-        isUnsupported: true,
-        abbr: ['idx.'], regex: rePosInt, map: x => parseInt(x),
-        level: 'atom-test'
+        regex: /[0-9+-]+/, map: listOrRangeMap,
+        level: 'atom-test',property: B.ammp('id')
     },
     ss: {
         '@desc': 'secondary-structure-type list of single letters. Helical regions should be assigned H and sheet regions S. Loop regions can either be assigned L or be blank.',
diff --git a/src/mol-script/transpilers/rasmol/keywords.ts b/src/mol-script/transpilers/rasmol/keywords.ts
index a693cd9424bacfeea11065ac104d027b20284e60..6b692089837e7c087fd14e5b2866a08c2048c7d9 100644
--- a/src/mol-script/transpilers/rasmol/keywords.ts
+++ b/src/mol-script/transpilers/rasmol/keywords.ts
@@ -10,506 +10,379 @@ const B = MolScriptBuilder;
 import * as h from '../helper';
 import { KeywordDict } from '../types';
 
+const Backbone = {
+    nucleic: ['P', "O3'", "O5'", "C5'", "C4'", "C3'", 'OP1', 'OP2', 'O3*', 'O5*', 'C5*', 'C4*', 'C3*'],
+    protein: ['C', 'N', 'CA', 'O']
+};
+
 
 function nucleicExpr() {
   return B.struct.combinator.merge([
-    B.struct.generator.atomGroups({
-      'residue-test': B.core.set.has([
-        B.set(...['G', 'C', 'A', 'T', 'U', 'I', 'DG', 'DC', 'DA', 'DT', 'DU', 'DI', '+G', '+C', '+A', '+T', '+U', '+I']),
-        B.ammp('label_comp_id')
-      ])
-    }),
-    B.struct.filter.pick({
-      0: B.struct.generator.atomGroups({
-        'group-by': B.ammp('residueKey')
+      B.struct.generator.atomGroups({
+	  'residue-test': B.core.set.has([
+              B.set(...['G', 'C', 'A', 'T', 'U', 'I', 'DG', 'DC', 'DA', 'DT', 'DU', 'DI', '+G', '+C', '+A', '+T', '+U', '+I']),
+              B.ammp('label_comp_id')
+	  ])
       }),
-      test: B.core.logic.and([
-        B.core.rel.eq([ B.struct.atomSet.atomCount(), 1 ]),
-        B.core.rel.eq([ B.ammp('label_atom_id'), B.atomName('P') ]),
-      ])
-    }),
-    B.struct.filter.pick({
-      0: B.struct.generator.atomGroups({
-        'group-by': B.ammp('residueKey')
+      B.struct.filter.pick({
+	  0: B.struct.generator.atomGroups({
+              'group-by': B.ammp('residueKey')
+	  }),
+	  test: B.core.logic.and([
+              B.core.rel.eq([ B.struct.atomSet.atomCount(), 1 ]),
+              B.core.rel.eq([ B.ammp('label_atom_id'), B.atomName('P') ]),
+	  ])
       }),
-      test: B.core.logic.or([
-        B.core.set.isSubset([
-          h.atomNameSet([ "C1'", "C2'", "O3'", "C3'", "C4'", "C5'", "O5'" ]),
-          B.ammpSet('label_atom_id')
-        ]),
-        B.core.set.isSubset([
-          h.atomNameSet([ 'C1*', 'C2*', 'O3*', 'C3*', 'C4*', 'C5*', 'O5*' ]),
-          B.ammpSet('label_atom_id')
-        ])
-      ])
-    })
+      B.struct.filter.pick({
+	  0: B.struct.generator.atomGroups({
+              'group-by': B.ammp('residueKey')
+	  }),
+	  test: B.core.logic.or([
+              B.core.set.isSubset([
+		  h.atomNameSet([ "C1'", "C2'", "O3'", "C3'", "C4'", "C5'", "O5'" ]),
+		  B.ammpSet('label_atom_id')
+              ]),
+              B.core.set.isSubset([
+		  h.atomNameSet([ 'C1*', 'C2*', 'O3*', 'C3*', 'C4*', 'C5*', 'O5*' ]),
+		  B.ammpSet('label_atom_id')
+              ])
+	  ])
+      })
   ])
 }
 
+
+
 const ResDict = {
-  acidic: ['ASP', 'GLU'],
-  aliphatic: ['ALA', 'GLY', 'ILE', 'LEU', 'VAL'],
-  amino: ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL', 'ASX', 'GLX', 'UNK', ],
-  aromatic: ['HIS', 'PHE', 'TRP', 'TYR'],
-  basic: ['ARG', 'HIS', 'LYS'],
-  buried: ['ALA','CYS', 'ILE', 'LEU', 'MET', 'PHE', 'TRP', 'VAL'],
-  cg: ['CYT', 'C', 'GUA', 'G'],
-  cyclic: ['HIS', 'PHE', 'PRO', 'TRP', 'TYR'],
-  hydrophobic: ['ALA', 'GLY', 'ILE', 'LEU', 'MET', 'PHE', 'PRO', 'TRP', 'TYR', 'VAL'],
-  large: ['ARG', 'GLU', 'GLN', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'TRP', 'TYR'],
-  medium: ['ASN', 'ASP', 'CYS', 'PRO', 'THR', 'VAL'],
-  small: ['ALA', 'GLY', 'SER'],
-}
+    aliphatic: ['ALA', 'GLY', 'ILE', 'LEU', 'VAL'],
+    amino: ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL', 'ASX', 'GLX', 'UNK', ],
+    acidic: ['ASP', 'GLU'],
+    aromatic: ['HIS', 'PHE', 'TRP', 'TYR'],
+    basic: ['ARG', 'HIS', 'LYS'],
+    buried: ['ALA','CYS', 'ILE', 'LEU', 'MET', 'PHE', 'TRP', 'VAL'],
+    cg: ['CYT', 'C', 'GUA', 'G'],
+    cyclic: ['HIS', 'PHE', 'PRO', 'TRP', 'TYR'],
+    hydrophobic: ['ALA', 'GLY', 'ILE', 'LEU', 'MET', 'PHE', 'PRO', 'TRP', 'TYR', 'VAL'],
+    large: ['ARG', 'GLU', 'GLN', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'TRP', 'TYR'],
+    medium: ['ASN', 'ASP', 'CYS', 'PRO', 'THR', 'VAL'],
+    small: ['ALA', 'GLY', 'SER'],
+    nucleic: ['A', 'C', 'T', 'G', 'U', 'DA', 'DC', 'DT', 'DG', 'DU'],
+    protein: ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'CYX', 'GLN', 'GLU', 'GLY', 'HIS', 'HID', 'HIE', 'HIP', 'ILE', 'LEU', 'LYS', 'MET', 'MSE', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL'],
+    solvent: ['HOH', 'WAT', 'H20', 'TIP', 'SOL']
+};
+
 
 export const keywords: KeywordDict = {
   // general terms
   all: {
-    '@desc': 'all atoms; same as *',
-    abbr: ['*'],
-    map: () => B.struct.generator.all()
-  },
-  bonded: {
-    '@desc': 'covalently bonded',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.gr([B.struct.atomProperty.core.bondCount({
-        flags: B.struct.type.bondFlags(['covalent', 'metallic', 'sulfide'])
-      }), 0])
-    })
-  },
-  clickable: {
-    '@desc': 'actually visible -- having some visible aspect such as wireframe, spacefill, or a label showing, or the alpha-carbon or phosphorus atom in a biomolecule that is rendered with only cartoon, rocket, or other biomolecule-specific shape.'
-  },
-  connected: {
-    '@desc': 'bonded in any way, including hydrogen bonds',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.gr([B.struct.atomProperty.core.bondCount({
-        flags: B.struct.type.bondFlags()
-      }), 0])
-    })
-  },
-  displayed: {
-    '@desc': 'displayed using the display or hide command; not necessarily visible'
-  },
-  hidden: {
-    '@desc': 'hidden using the display or hide command'
-  },
-  none: {
-    '@desc': 'no atoms',
-    map: () => B.struct.generator.empty()
-  },
-  selected: {
-    '@desc': 'atoms that have been selected; defaults to all when a file is first loaded'
-  },
-  thisModel: {
-    '@desc': 'atoms in the current frame set, as defined by frame, model, or animation commands. If more than one model is in this set, "thisModel" refers to all of them, regardless of atom displayed/hidden status.'
-  },
-  visible: {
-    '@desc': 'visible in any way, including PDB residue atoms for which a cartoon or other such rendering makes their group visible, even if they themselves are not visible.'
-  },
-  subset: {
-    '@desc': 'the currently defined subset. Note that if a subset is currently defined, then select/display all is the same as select/display subset, restrict none is the same as restrict not subset. In addition, select not subset selects nothing.'
-  },
-  specialPosition: {
-    '@desc': 'atoms in crystal structures that are at special positions - that is, for which there is more than one operator that leads to them.'
-  },
-  unitcell: {
-    '@desc': 'atoms within the current unitcell, which may be offset. This includes atoms on the faces and at the vertices of the unitcell.'
-  },
-  polyhedra: {
-    '@desc': 'all central atoms for which polyhedra have been created. See also polyhera(n), below. (Jmol 14.4)'
-  },
-  nonmetal: {
-    '@desc': '_H,_He,_B,_C,_N,_O,_F,_Ne,_Si,_P,_S,_Cl,_Ar,_As,_Se,_Br,_Kr,_Te,_I,_Xe,_At,_Rn',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.set.has([
-        B.set(...['H','He','B','C','N','O','F','Ne','Si','P','S','Cl','Ar','As','Se','Br','Kr','Te','I','Xe','At','Rn'].map(B.es)),
-        B.acp('elementSymbol')
-      ])
-    })
-  },
-  metal: {
-    '@desc': '!nonmetal',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.logic.not([
-        B.core.set.has([
-          B.set(...['H','He','B','C','N','O','F','Ne','Si','P','S','Cl','Ar','As','Se','Br','Kr','Te','I','Xe','At','Rn'].map(B.es)),
-          B.acp('elementSymbol')
-        ])
-      ])
-    })
-  },
-  alkaliMetal: {
-    '@desc': '_Li,_Na,_K,_Rb,_Cs,_Fr',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.set.has([
-        B.set(...['Li','Na','K','Rb','Cs','Fr'].map(B.es)),
-        B.acp('elementSymbol')
-      ])
-    })
-  },
-  alkalineEarth: {
-    '@desc': '_Be,_Mg,_Ca,_Sr,_Ba,_Ra',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.set.has([
-        B.set(...['Be','Mg','Ca','Sr','Ba','Ra'].map(B.es)),
-        B.acp('elementSymbol')
-      ])
-    })
-  },
-  nobleGas: {
-    '@desc': '_He,_Ne,_Ar,_Kr,_Xe,_Rn',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.set.has([
-        B.set(...['He','Ne','Ar','Kr','Xe','Rn'].map(B.es)),
-        B.acp('elementSymbol')
-      ])
-    })
-  },
-  metalloid: {
-    '@desc': '_B,_Si,_Ge,_As,_Sb,_Te',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.set.has([
-        B.set(...['B','Si','Ge','As','Sb','Te'].map(B.es)),
-        B.acp('elementSymbol')
-      ])
-    })
-  },
-  transitionMetal: {
-    '@desc': '(includes La and Ac) elemno>=21 and elemno<=30, elemno=57, elemno=89, elemno>=39 and elemno<=48, elemno>=72 and elemno<=80, elemno>=104 and elemno<=112',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.logic.or([
-        B.core.rel.inRange([B.acp('atomicNumber'), 21, 30]),
-        B.core.rel.inRange([B.acp('atomicNumber'), 39, 48]),
-        B.core.rel.inRange([B.acp('atomicNumber'), 72, 80]),
-        B.core.rel.inRange([B.acp('atomicNumber'), 104, 112]),
-        B.core.set.has([B.set(57, 89), B.acp('atomicNumber')])
-      ])
-    })
-  },
-  lanthanide: {
-    '@desc': '(does not include La) elemno>57 and elemno<=71',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.inRange([B.acp('atomicNumber'), 57, 71])
-    })
-  },
-  actinide: {
-    '@desc': '(does not include Ac) elemno>89 and elemno<=103',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.inRange([B.acp('atomicNumber'), 89, 103])
-    })
-  },
-  isaromatic: {
-    '@desc': 'atoms connected with the AROMATIC, AROMATICSINGLE, or AROMATICDOUBLE bond types',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.gr([
-        B.struct.atomProperty.core.bondCount({
-          flags: B.struct.type.bondFlags(['aromatic'])
-        }),
-        0
-      ])
-    })
-  },
-
-  carbohydrate: {
-    '@desc': ''
-  },
-  ions: {
-    '@desc': '(specifically the PDB designations "PO4" and "SO4")'
-  },
-  ligand: {
-    '@desc': '(originally "hetero and not solvent"; changed to "!(protein,nucleic,water,UREA)" for Jmol 12.2)'
-  },
-  nucleic: {
-    '@desc': 'any group that (a) has one of the following group names: G, C, A, T, U, I, DG, DC, DA, DT, DU, DI, +G, +C, +A, +T, +U, +I; or (b) can be identified as a group that is only one atom, with name "P"; or (c) has all of the following atoms (prime, \', can replace * here): C1*, C2*, C3*, O3*, C4*, C5*, and O5*.',
-    map: () => nucleicExpr()
-  },
-  purine: {
-    '@desc': 'any nucleic group that (a) has one of the following group names: A, G, I, DA, DG, DI, +A, +G, or +I; or (b) also has atoms N7, C8, and N9.',
-    map: () => B.struct.modifier.intersectBy({
-      0: nucleicExpr(),
-      by: B.struct.combinator.merge([
-        B.struct.generator.atomGroups({
-          'residue-test': B.core.set.has([
-            B.set(...['A', 'G', 'I', 'DA', 'DG', 'DI', '+A', '+G', '+I']),
-            B.ammp('label_comp_id')
-          ])
-        }),
-        B.struct.filter.pick({
-          0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-          }),
-          test: B.core.set.isSubset([
-            h.atomNameSet([ 'N7', 'C8', 'N9' ]),
-            B.ammpSet('label_atom_id')
-          ])
-        })
-      ])
+      '@desc': 'all atoms; same as *',
+      abbr: ['*'],
+      map: () => B.struct.generator.all()
+  },
+    none: {
+	'@desc': 'no atoms',
+	map: () => B.struct.generator.empty()
+  },
+    selected: {
+	'@desc': 'atoms that have been selected; defaults to all when a file is first loaded'
+    },
+    unitcell: {
+	'@desc': 'atoms within the current unitcell, which may be offset. This includes atoms on the faces and at the vertices of the unitcell.'
+    },
+    ions: {
+	'@desc': '(specifically the PDB designations "PO4" and "SO4")'
+    },
+    ligand: {
+	'@desc': '(originally "hetero and not solvent"; changed to "!(protein,nucleic,water,UREA)" for Jmol 12.2)'
+    },
+    nucleic: {
+	'@desc': 'any group that (a) has one of the following group names: G, C, A, T, U, I, DG, DC, DA, DT, DU, DI, +G, +C, +A, +T, +U, +I; or (b) can be identified as a group that is only one atom, with name "P"; or (c) has all of the following atoms (prime, \', can replace * here): C1*, C2*, C3*, O3*, C4*, C5*, and O5*.',
+	map: () => nucleicExpr()
+    },
+    purine: {
+	'@desc': 'any nucleic group that (a) has one of the following group names: A, G, I, DA, DG, DI, +A, +G, or +I; or (b) also has atoms N7, C8, and N9.',
+	map: () => B.struct.modifier.intersectBy({
+	    0: nucleicExpr(),
+	    by: B.struct.combinator.merge([
+		B.struct.generator.atomGroups({
+		    'residue-test': B.core.set.has([
+			B.set(...['A', 'G', 'I', 'DA', 'DG', 'DI', '+A', '+G', '+I']),
+			B.ammp('label_comp_id')
+		    ])
+		}),
+		B.struct.filter.pick({
+		    0: B.struct.generator.atomGroups({
+			'group-by': B.ammp('residueKey')
+		    }),
+		    test: B.core.set.isSubset([
+			h.atomNameSet([ 'N7', 'C8', 'N9' ]),
+			B.ammpSet('label_atom_id')
+		    ])
+		})
+	    ])
+	})
+    },
+    pyrimidine: {
+	'@desc': 'any nucleic group that (a) has one of the following group names: C, T, U, DC, DT, DU, +C, +T, +U; or (b) also has atom O2.',
+	map: () => B.struct.modifier.intersectBy({
+	    0: nucleicExpr(),
+	    by: B.struct.combinator.merge([
+		B.struct.generator.atomGroups({
+		    'residue-test': B.core.set.has([
+			B.set(...['C', 'T', 'U', 'DC', 'DT', 'DU', '+C', '+T', '+U']),
+			B.ammp('label_comp_id')
+		    ])
+		}),
+		B.struct.filter.pick({
+		    0: B.struct.generator.atomGroups({
+			'group-by': B.ammp('residueKey')
+		    }),
+		    test: B.core.logic.or([
+			B.core.set.has([
+			    B.ammpSet('label_atom_id'),
+			    B.atomName('O2*')
+			]),
+			B.core.set.has([
+			    B.ammpSet('label_atom_id'),
+			    B.atomName("O2'")
+			])
+		    ])
+		})
+	    ])
+	})
+    },
+    dna: {
+	'@desc': 'any nucleic group that (a) has one of the following group names: DG, DC, DA, DT, DU, DI, T, +G, +C, +A, +T; or (b) has neither atom O2* or O2\'.',
+	map: () => B.struct.modifier.intersectBy({
+	    0: nucleicExpr(),
+	    by: B.struct.combinator.merge([
+		B.struct.generator.atomGroups({
+		    'residue-test': B.core.set.has([
+			B.set(...['DG', 'DC', 'DA', 'DT', 'DU', 'DI', 'T', '+G', '+C', '+A', '+T']),
+			B.ammp('label_comp_id')
+		    ])
+		}),
+		B.struct.filter.pick({
+		    0: B.struct.generator.atomGroups({
+			'group-by': B.ammp('residueKey')
+		    }),
+		    test: B.core.logic.not([
+			B.core.logic.or([
+			    B.core.set.has([
+				B.ammpSet('label_atom_id'),
+				B.atomName('O2*')
+			    ]),
+			    B.core.set.has([
+				B.ammpSet('label_atom_id'),
+				B.atomName("O2'")
+			    ])
+			])
+		    ])
+		})
+	    ])
+	})
+    },
+    rna: {
+	'@desc': 'any nucleic group that (a) has one of the following group names: G, C, A, U, I, +U, +I; or (b) has atom O2* or O2\'.',
+	map: () => B.struct.modifier.intersectBy({
+	    0: nucleicExpr(),
+	    by: B.struct.combinator.merge([
+		B.struct.generator.atomGroups({
+		    'residue-test': B.core.set.has([
+			B.set(...['G', 'C', 'A', 'U', 'I', '+U', '+I']),
+			B.ammp('label_comp_id')
+		    ])
+		}),
+		B.struct.filter.pick({
+		    0: B.struct.generator.atomGroups({
+			'group-by': B.ammp('residueKey')
+		    }),
+		    test: B.core.logic.or([
+			B.core.set.has([
+			    B.ammpSet('label_atom_id'),
+			    B.atomName('O2*')
+			]),
+			B.core.set.has([
+			    B.ammpSet('label_atom_id'),
+			    B.atomName("O2'")
+			])
+		    ])
+		})
+	    ])
+	})
+    },
+    protein: {
+	'@desc': 'defined as a group that (a) has one of the following group names: ALA, ARG, ASN, ASP, CYS, GLN, GLU, GLY, HIS, ILE, LEU}, LYS, MET, PHE, PRO, SER, THR, TRP, TYR, VAL, ASX, GLX, or UNK; or (b) contains PDB atom designations [C, O, CA, and N] bonded correctly; or (c) does not contain "O" but contains [C, CA, and N] bonded correctly; or (d) has only one atom, which has name CA and does not have the group name CA (indicating a calcium atom).',
+	map: () => proteinExpr()	
+    },
+    acidic: {
+	'@desc': 'ASP GLU',
+      map: () => h.resnameExpr(ResDict.acidic)
+  },
+    acyclic: {
+      '@desc': 'amino and not cyclic',
+      map: () => B.struct.modifier.intersectBy({
+	0: h.resnameExpr(ResDict.amino),
+	by: h.invertExpr(h.resnameExpr(ResDict.cyclic))
     })
   },
-  pyrimidine: {
-    '@desc': 'any nucleic group that (a) has one of the following group names: C, T, U, DC, DT, DU, +C, +T, +U; or (b) also has atom O2.',
-    map: () => B.struct.modifier.intersectBy({
-      0: nucleicExpr(),
-      by: B.struct.combinator.merge([
-        B.struct.generator.atomGroups({
-          'residue-test': B.core.set.has([
-            B.set(...['C', 'T', 'U', 'DC', 'DT', 'DU', '+C', '+T', '+U']),
-            B.ammp('label_comp_id')
-          ])
-        }),
-        B.struct.filter.pick({
-          0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-          }),
-          test: B.core.logic.or([
-            B.core.set.has([
-              B.ammpSet('label_atom_id'),
-              B.atomName('O2*')
-            ]),
-            B.core.set.has([
-              B.ammpSet('label_atom_id'),
-              B.atomName("O2'")
-            ])
-          ])
-        })
-      ])
-    })
+    aliphatic: {
+      '@desc': 'ALA GLY ILE LEU VAL',
+      map: () => h.resnameExpr(ResDict.aliphatic)
   },
-  dna: {
-    '@desc': 'any nucleic group that (a) has one of the following group names: DG, DC, DA, DT, DU, DI, T, +G, +C, +A, +T; or (b) has neither atom O2* or O2\'.',
-    map: () => B.struct.modifier.intersectBy({
-      0: nucleicExpr(),
-      by: B.struct.combinator.merge([
-        B.struct.generator.atomGroups({
-          'residue-test': B.core.set.has([
-            B.set(...['DG', 'DC', 'DA', 'DT', 'DU', 'DI', 'T', '+G', '+C', '+A', '+T']),
-            B.ammp('label_comp_id')
-          ])
-        }),
-        B.struct.filter.pick({
-          0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-          }),
-          test: B.core.logic.not([
-            B.core.logic.or([
-              B.core.set.has([
-                B.ammpSet('label_atom_id'),
-                B.atomName('O2*')
-              ]),
-              B.core.set.has([
-                B.ammpSet('label_atom_id'),
-                B.atomName("O2'")
-              ])
-            ])
-          ])
-        })
-      ])
-    })
+    amino: {
+      '@desc': 'all twenty standard amino acids, plus ASX, GLX, UNK',
+      map: () => h.resnameExpr(ResDict.amino)
   },
-  rna: {
-    '@desc': 'any nucleic group that (a) has one of the following group names: G, C, A, U, I, +U, +I; or (b) has atom O2* or O2\'.',
-    map: () => B.struct.modifier.intersectBy({
-      0: nucleicExpr(),
-      by: B.struct.combinator.merge([
-        B.struct.generator.atomGroups({
-          'residue-test': B.core.set.has([
-            B.set(...['G', 'C', 'A', 'U', 'I', '+U', '+I']),
-            B.ammp('label_comp_id')
-          ])
-        }),
-        B.struct.filter.pick({
-          0: B.struct.generator.atomGroups({
-            'group-by': B.ammp('residueKey')
-          }),
-          test: B.core.logic.or([
-            B.core.set.has([
-              B.ammpSet('label_atom_id'),
-              B.atomName('O2*')
-            ]),
-            B.core.set.has([
-              B.ammpSet('label_atom_id'),
-              B.atomName("O2'")
-            ])
-          ])
-        })
-      ])
-    })
+    aromatic: {
+      '@desc': 'HIS PHE TRP TYR (see also "isaromatic" for aromatic bonds)',
+      map: () => h.resnameExpr(ResDict.aromatic)
   },
-  protein: {
-    '@desc': 'defined as a group that (a) has one of the following group names: ALA, ARG, ASN, ASP, CYS, GLN, GLU, GLY, HIS, ILE, LEU, LYS, MET, PHE, PRO, SER, THR, TRP, TYR, VAL, ASX, GLX, or UNK; or (b) contains PDB atom designations [C, O, CA, and N] bonded correctly; or (c) does not contain "O" but contains [C, CA, and N] bonded correctly; or (d) has only one atom, which has name CA and does not have the group name CA (indicating a calcium atom).'
+    basic: {
+      '@desc': 'ARG HIS LYS',
+      map: () => h.resnameExpr(ResDict.basic)
   },
-  acidic: {
-    '@desc': 'ASP GLU',
-    map: () => h.resnameExpr(ResDict.acidic)
+    buried: {
+      '@desc': 'ALA CYS ILE LEU MET PHE TRP VAL',
+      map: () => h.resnameExpr(ResDict.buried)
   },
-  acyclic: {
-    '@desc': 'amino and not cyclic',
-    map: () => B.struct.modifier.intersectBy({
-      0: h.resnameExpr(ResDict.amino),
-      by: h.invertExpr(h.resnameExpr(ResDict.cyclic))
-    })
+    charged: {
+      '@desc': 'same as acidic or basic -- ASP GLU, ARG HIS LYS',
+      map: () => h.resnameExpr(ResDict.acidic.concat(ResDict.basic))
   },
-  aliphatic: {
-    '@desc': 'ALA GLY ILE LEU VAL',
-    map: () => h.resnameExpr(ResDict.aliphatic)
+    cyclic: {
+      '@desc': 'HIS PHE PRO TRP TYR',
+      map: () => h.resnameExpr(ResDict.cyclic)
   },
-  amino: {
-    '@desc': 'all twenty standard amino acids, plus ASX, GLX, UNK',
-    map: () => h.resnameExpr(ResDict.amino)
-  },
-  aromatic: {
-    '@desc': 'HIS PHE TRP TYR (see also "isaromatic" for aromatic bonds)',
-    map: () => h.resnameExpr(ResDict.aromatic)
-  },
-  basic: {
-    '@desc': 'ARG HIS LYS',
-    map: () => h.resnameExpr(ResDict.basic)
-  },
-  buried: {
-    '@desc': 'ALA CYS ILE LEU MET PHE TRP VAL',
-    map: () => h.resnameExpr(ResDict.buried)
-  },
-  charged: {
-    '@desc': 'same as acidic or basic -- ASP GLU, ARG HIS LYS',
-    map: () => h.resnameExpr(ResDict.acidic.concat(ResDict.basic))
-  },
-  cyclic: {
-    '@desc': 'HIS PHE PRO TRP TYR',
-    map: () => h.resnameExpr(ResDict.cyclic)
-  },
-  helix: {
-    '@desc': 'secondary structure-related.',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['helix']),
-        B.ammp('secondaryStructureFlags')
-      ])
-    })
-  },
-  helixalpha: {
-    '@desc': 'secondary structure-related.',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['alpha']),
-        B.ammp('secondaryStructureFlags')
-      ])
-    })
-  },
-  helix310: {
-    '@desc': 'secondary structure-related.',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['3-10']),
-        B.ammp('secondaryStructureFlags')
-      ])
-    })
-  },
-  helixpi: {
-    '@desc': 'secondary structure-related.',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['pi']),
-        B.ammp('secondaryStructureFlags')
+    helix: {
+      '@desc': 'secondary structure-related.',
+      map: () => B.struct.generator.atomGroups({
+	'residue-test': B.core.flags.hasAny([
+          B.struct.type.secondaryStructureFlags(['helix']),
+          B.ammp('secondaryStructureFlags')
       ])
     })
   },
-  hetero: {
-    '@desc': 'PDB atoms designated as HETATM',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.ammp('isHet')
+    hetero: {
+      '@desc': 'PDB atoms designated as HETATM',
+      map: () => B.struct.generator.atomGroups({
+	'atom-test': B.ammp('isHet')
     })
   },
-  hydrophobic: {
-    '@desc': 'ALA GLY ILE LEU MET PHE PRO TRP TYR VAL',
-    map: () => h.resnameExpr(ResDict.hydrophobic)
+    hydrophobic: {
+      '@desc': 'ALA GLY ILE LEU MET PHE PRO TRP TYR VAL',
+      map: () => h.resnameExpr(ResDict.hydrophobic)
   },
-  large: {
-    '@desc': 'ARG GLU GLN HIS ILE LEU LYS MET PHE TRP TYR',
-    map: () => h.resnameExpr(ResDict.large)
+    large: {
+      '@desc': 'ARG GLU GLN HIS ILE LEU LYS MET PHE TRP TYR',
+      map: () => h.resnameExpr(ResDict.large)
   },
-  medium: {
-    '@desc': 'ASN ASP CYS PRO THR VAL',
-    map: () => h.resnameExpr(ResDict.medium)
+    medium: {
+      '@desc': 'ASN ASP CYS PRO THR VAL',
+      map: () => h.resnameExpr(ResDict.medium)
   },
-  negative: {
-    '@desc': 'same as acidic -- ASP GLU',
-    map: () => h.resnameExpr(ResDict.acidic)
+    negative: {
+      '@desc': 'same as acidic -- ASP GLU',
+      map: () => h.resnameExpr(ResDict.acidic)
   },
-  neutral: {
-    '@desc': 'amino and not (acidic or basic)',
-    map: () => B.struct.modifier.intersectBy({
-      0: h.resnameExpr(ResDict.amino),
-      by: h.invertExpr(h.resnameExpr(ResDict.acidic.concat(ResDict.basic)))
+    neutral: {
+      '@desc': 'amino and not (acidic or basic)',
+      map: () => B.struct.modifier.intersectBy({
+	0: h.resnameExpr(ResDict.amino),
+	by: h.invertExpr(h.resnameExpr(ResDict.acidic.concat(ResDict.basic)))
     })
   },
-  polar: {
-    '@desc': 'amino and not hydrophobic',
-    map: () => B.struct.modifier.intersectBy({
-      0: h.resnameExpr(ResDict.amino),
-      by: h.invertExpr(h.resnameExpr(ResDict.hydrophobic))
+    polar: {
+      '@desc': 'amino and not hydrophobic',
+      map: () => B.struct.modifier.intersectBy({
+	0: h.resnameExpr(ResDict.amino),
+	by: h.invertExpr(h.resnameExpr(ResDict.hydrophobic))
     })
   },
-  positive: {
-    '@desc': 'same as basic -- ARG HIS LYS',
-    map: () => h.resnameExpr(ResDict.basic)
+    positive: {
+      '@desc': 'same as basic -- ARG HIS LYS',
+      map: () => h.resnameExpr(ResDict.basic)
   },
-  sheet: {
-    '@desc': 'secondary structure-related',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['sheet']),
-        B.ammp('secondaryStructureFlags')
+    sheet: {
+      '@desc': 'secondary structure-related',
+      map: () => B.struct.generator.atomGroups({
+	'residue-test': B.core.flags.hasAny([
+          B.struct.type.secondaryStructureFlags(['sheet']),
+          B.ammp('secondaryStructureFlags')
       ])
     })
   },
-  small: {
-    '@desc': 'ALA GLY SER',
-    map: () => h.resnameExpr(ResDict.small)
-  },
-  surface: {
-    '@desc': 'amino and not buried',
-    map: () => B.struct.modifier.intersectBy({
-      0: h.resnameExpr(ResDict.amino),
-      by: h.invertExpr(h.resnameExpr(ResDict.buried))
-    })
+    small: {
+      '@desc': 'ALA GLY SER',
+      map: () => h.resnameExpr(ResDict.small)
   },
-  turn: {
-    '@desc': 'secondary structure-related',
-    map: () => B.struct.generator.atomGroups({
-      'residue-test': B.core.flags.hasAny([
-        B.struct.type.secondaryStructureFlags(['turn']),
-        B.ammp('secondaryStructureFlags')
+    turn: {
+      '@desc': 'secondary structure-related',
+      map: () => B.struct.generator.atomGroups({
+	'residue-test': B.core.flags.hasAny([
+          B.struct.type.secondaryStructureFlags(['turn']),
+          B.ammp('secondaryStructureFlags')
       ])
     })
   },
-  alpha: {
-    '@desc': '(*.CA)',
-    map: () => B.struct.generator.atomGroups({
-      'atom-test': B.core.rel.eq([
-        B.atomName('CA'),
-        B.ammp('label_atom_id')
+    alpha: {
+      '@desc': '(*.CA)',
+      map: () => B.struct.generator.atomGroups({
+	'atom-test': B.core.rel.eq([
+          B.atomName('CA'),
+          B.ammp('label_atom_id')
       ])
     })
   },
-  base: {
-    '@desc': '(nucleic bases)'
-  },
-  backbone: {
-    '@desc': '(*.C, *.CA, *.N, and all nucleic other than the bases themselves)',
-    abbr: ['mainchain']
+    base: {
+      '@desc': '(nucleic bases)'
   },
-  sidechain: {
-    '@desc': '((protein or nucleic) and not backbone)'
+    backbone: {
+      '@desc': '(*.C, *.CA, *.N, and all nucleic other than the bases themselves)',
+      abbr: ['mainchain'],
+      map: () => backboneExpr()
   },
-  spine: {
-    '@desc': '(*.CA, *.N, *.C for proteins; *.P, *.O3\', *.O5\', *.C3\', *.C4\', *.C5 for nucleic acids)'
-  },
-  leadatom: {
-    '@desc': '(*.CA, *.P, and terminal *.O5\')'
-  },
-  solvent: {
-    '@desc': 'PDB "HOH", water, also the connected set of H-O-H in any model'
+    sidechain: {
+	'@desc': '((protein or nucleic) and not backbone)'
   },
+    solvent: {
+	'@desc': 'PDB "HOH", water, also the connected set of H-O-H in any model',
+	    map: () => h.resnameExpr(ResDict.solvent)	
+    },
+};
+
+function backboneExpr() {
+    return B.struct.combinator.merge([
+        B.struct.generator.queryInSelection({
+            0: proteinExpr(),
+            query: B.struct.generator.atomGroups({
+                'atom-test': B.core.set.has([
+                    h.atomNameSet(Backbone.protein),
+                    B.ammp('label_atom_id')
+                ])
+            })
+        }),
+        B.struct.generator.queryInSelection({
+            0: nucleicExpr(),
+            query: B.struct.generator.atomGroups({
+                'atom-test': B.core.set.has([
+                    h.atomNameSet(Backbone.nucleic),
+                    B.ammp('label_atom_id')
+                ])
+            })
+        })
+    ]);
 }
 
+function proteinExpr() {
+    return B.struct.filter.pick({
+        0: B.struct.generator.atomGroups({
+            'group-by': B.ammp('residueKey')
+        }),
+        test: B.core.set.isSubset([
+            h.atomNameSet(['C', 'N', 'CA', 'O']),
+            B.ammpSet('label_atom_id')
+        ])
+    });
+}
 
diff --git a/src/mol-script/transpilers/rasmol/parser.ts b/src/mol-script/transpilers/rasmol/parser.ts
index 93b79b1d2823982f100a8fcffe7222111eaeeb57..67a08a0c24057f4fe53ecbc1b56cd3030a95ae19 100644
--- a/src/mol-script/transpilers/rasmol/parser.ts
+++ b/src/mol-script/transpilers/rasmol/parser.ts
@@ -120,24 +120,28 @@ const lang = P.MonadicParser.createLanguage({
   },
 
     Expression: function(r:any) {
-    return P.MonadicParser.alt(
-      r.Keywords,
-
-	r.Resno.lookahead(P.MonadicParser.regexp(/\s*(?!(LIKE|>=|<=|!=|[:^%/.=><]))/i)).map((x:any) => B.struct.generator.atomGroups({
-          'residue-test': B.core.rel.eq([ B.ammp('auth_seq_id'), x ])
-      })),
-      r.AtomExpression.map(atomExpressionQuery),
-
-      r.ValueQuery,
-
-      r.Element.map((x: string) => B.struct.generator.atomGroups({
-        'atom-test': B.core.rel.eq([ B.acp('elementSymbol'), B.struct.type.elementSymbol(x) ])
-      })),
-      r.Resname.map((x: string) => B.struct.generator.atomGroups({
-        'residue-test': B.core.rel.eq([ B.ammp('label_comp_id'), x ])
-      })),
-    )
-  },
+	return P.MonadicParser.alt(
+	    r.NamedAtomProperties,
+	    r.Keywords,
+	    r.Resno.lookahead(P.MonadicParser.regexp(/\s*(?!(LIKE|>=|<=|!=|[:^%/.=><]))/i)).map((x:any) => B.struct.generator.atomGroups({
+		'residue-test': B.core.rel.eq([ B.ammp('auth_seq_id'), x ])
+	    })),
+	    r.AtomExpression.map(atomExpressionQuery),
+	    
+	    r.ValueQuery,
+	    
+	    r.Element.map((x: string) => B.struct.generator.atomGroups({
+		'atom-test': B.core.rel.eq([ B.acp('elementSymbol'), B.struct.type.elementSymbol(x) ])
+	    })),
+	    r.Resname.map((x: string) => B.struct.generator.atomGroups({
+		'residue-test': B.core.rel.eq([ B.ammp('label_comp_id'), x ])
+	    })),
+	)
+    },
+
+    NamedAtomProperties: function () {
+        return P.MonadicParser.alt(...h.getNamedPropertyRules(properties)); 
+    },
 
 Operator: function(r:any) {
     return h.combineOperators(operators, P.MonadicParser.alt(r.Parens, r.Expression))
@@ -145,41 +149,45 @@ Operator: function(r:any) {
 
 AtomExpression: function(r:any) {
     return P.MonadicParser.seq(
-      P.MonadicParser.lookahead(r.AtomPrefix),
-      P.MonadicParser.seq(
-        r.Resno.or(P.MonadicParser.of(null)),
-        r.Inscode.or(P.MonadicParser.of(null)),
-        r.Chainname.or(P.MonadicParser.of(null)),
-        r.Atomname.or(P.MonadicParser.of(null)),
-        r.Altloc.or(P.MonadicParser.of(null)),
-        r.Model.or(P.MonadicParser.of(null))
-      )
+	P.MonadicParser.lookahead(r.AtomPrefix),
+	P.MonadicParser.seq(
+            r.Resno.or(P.MonadicParser.of(null)),
+            r.Inscode.or(P.MonadicParser.of(null)),
+            r.Chainname.or(P.MonadicParser.of(null)),
+            r.Atomname.or(P.MonadicParser.of(null)),
+            r.Altloc.or(P.MonadicParser.of(null)),
+            r.Model.or(P.MonadicParser.of(null))),	
     )
   },
 
-  AtomPrefix: () => P.MonadicParser.regexp(/[0-9:^%/.]/).desc('atom-prefix'),
-
-  Chainname: () => P.MonadicParser.regexp(/:([A-Za-z]{1,3})/, 1).desc('chainname'),
-  Model: () => P.MonadicParser.regexp(/\/([0-9]+)/, 1).map(Number).desc('model'),
-  Element: () => P.MonadicParser.regexp(/_([A-Za-z]{1,3})/, 1).desc('element'),
-  Atomname: () => P.MonadicParser.regexp(/\.([a-zA-Z0-9]{1,4})/, 1).map(B.atomName).desc('atomname'),
-  Resname: () => P.MonadicParser.regexp(/[a-zA-Z0-9]{1,4}/).desc('resname'),
-Resno: (r:any) => r.Integer.desc('resno'),
-  Altloc: () => P.MonadicParser.regexp(/%([a-zA-Z0-9])/, 1).desc('altloc'),
-  Inscode: () => P.MonadicParser.regexp(/\^([a-zA-Z0-9])/, 1).desc('inscode'),
-
-  // BracketedResname: function (r) {
-  //   return P.MonadicParser.regexp(/\.([a-zA-Z0-9]{1,4})/, 1)
-  //     .desc('bracketed-resname')
-  //   // [0SD]
-  // },
-
-  // ResnoRange: function (r) {
-  //   return P.MonadicParser.regexp(/\.([\s]){1,3}/, 1)
-  //     .desc('resno-range')
-  //   // 123-200
-  //   // -12--3
-  // },
+    AtomPrefix: () => P.MonadicParser.regexp(/[0-9:^%/.]/).desc('atom-prefix'),
+    Chainname: () => P.MonadicParser.regexp(/:([A-Za-z]{1,3})/, 1).desc('chainname'),
+    Model: () => P.MonadicParser.regexp(/\/([0-9]+)/, 1).map(Number).desc('model'),
+    Element: () => P.MonadicParser.regexp(/_([A-Za-z]{1,3})/, 1).desc('element'),
+    Atomname: () => P.MonadicParser.regexp(/\.([a-zA-Z0-9]{1,4})/, 1).map(B.atomName).desc('atomname'),
+    Resname: () => P.MonadicParser.regexp(/[a-zA-Z0-9]{1,4}/).desc('resname'),
+    Resno: (r:any) => r.Integer.desc('resno'),
+    Resno2: (r:any) => r.split(',').Integer.desc("resno"),
+    Altloc: () => P.MonadicParser.regexp(/%([a-zA-Z0-9])/, 1).desc('altloc'),
+    Inscode: () => P.MonadicParser.regexp(/\^([a-zA-Z0-9])/, 1).desc('inscode'),
+
+
+//    function listMap(x: string) { return x.split(',').map(x => x.replace(/^["']|["']$/g, '')); }
+
+
+
+    BracketedResname: function (r:any) {
+	return P.MonadicParser.regexp(/\.([a-zA-Z0-9]{1,4})/, 1)
+	    .desc('bracketed-resname')
+	// [0SD]
+    },
+
+    ResnoRange: function (r:any) {
+	return P.MonadicParser.regexp(/\.([\s]){1,3}/, 1)
+	    .desc('resno-range')
+	// 123-200
+	// -12--3
+    },
 
   Keywords: () => P.MonadicParser.alt(...h.getKeywordRules(keywords)),
 
diff --git a/src/mol-script/transpilers/rasmol/properties.ts b/src/mol-script/transpilers/rasmol/properties.ts
index f675678a05c72f263f19e2383ff859ece7113cea..133840440f33a2ce927201eef7004d5caafbde3c 100644
--- a/src/mol-script/transpilers/rasmol/properties.ts
+++ b/src/mol-script/transpilers/rasmol/properties.ts
@@ -23,10 +23,6 @@ const structureDict: {[key: string]: string} = {
   helix: 'helix',
   dna: 'dna',
   rna: 'rna',
-  carbohydrate: 'carbohydrate',
-  helix310: '3-10',
-  helixalpha: 'alpha',
-  helixpi: 'pi',
 
   0: 'none',
   1: 'turn',
@@ -50,44 +46,23 @@ export function structureMap(x: any) {
 }
 
 export const properties: PropertyDict = {
-  adpmax: {
-    '@desc': 'the maximum anisotropic displacement parameter for the selected atom',
-    '@examples': [''],
-    isUnsupported: true,
-    regex: reFloat, map: x => parseFloat(x),
-    level: 'atom-test'
-  },
-  adpmin: {
-    '@desc': 'the minimum anisotropic displacement parameter for the selected atom',
-    '@examples': [''],
-    isUnsupported: true,
-    regex: reFloat, map: x => parseFloat(x),
-    level: 'atom-test'
-  },
-  altloc: {
-    '@desc': 'PDB alternate location identifier',
-    '@examples': ['altloc = A'],
-    regex: /[a-zA-Z0-9]/, map: str,
-    level: 'atom-test', property: B.ammp('label_alt_id')
-  },
-  altname: {
-    '@desc': 'an alternative name given to atoms by some file readers (for example, P2N)',
-    '@examples': [''],
-    isUnsupported: true,
-    regex: /[a-zA-Z0-9]/, map: str,
-    level: 'atom-test'
-  },
-  atomID: {
-    '@desc': 'special atom IDs for PDB atoms assigned by Jmol',
-    '@examples': [''],
+    altloc: {
+	'@desc': 'PDB alternate location identifier',
+	'@examples': ['altloc = A'],
+	regex: /[a-zA-Z0-9]/, map: str,
+	level: 'atom-test', property: B.ammp('label_alt_id')
+    },    
+    atomID: {
+	'@desc': 'special atom IDs for PDB atoms assigned by Jmol',
+	'@examples': [''],
     isUnsupported: true,
     regex: rePosInt, map: x => parseInt(x),
     level: 'atom-test'
-  },
-  atomIndex: {
-    '@desc': 'atom 0-based index; a unique number for each atom regardless of the number of models loaded',
-    '@examples': [''],
-    isUnsupported: true,
+    },
+    atomIndex: {
+	'@desc': 'atom 0-based index; a unique number for each atom regardless of the number of models loaded',
+	'@examples': [''],
+	isUnsupported: true,
     regex: rePosInt, map: x => parseInt(x),
     level: 'atom-test'
   },
@@ -100,9 +75,9 @@ export const properties: PropertyDict = {
   atomno: {
     '@desc': 'sequential number; you can use "@" instead of "atomno=" -- for example, select @33 or Var x = @33 or @35',
     '@examples': [''],
-    isUnsupported: true,
+    isNumeric: true,
     regex: rePosInt, map: x => parseInt(x),
-    level: 'atom-test'
+    level: 'atom-test', property: B.ammp('id')
   },
   atomType: {
     '@desc': 'atom type (mol2, AMBER files) or atom name (other file types)',
@@ -205,10 +180,11 @@ export const properties: PropertyDict = {
     level: 'atom-test', property: B.acp('elementSymbol')
   },
   elemno: {
-    '@desc': 'atomic element number',
-    '@examples': ['elemno=8'],
-    regex: /[0-9\s{}-]+/, map: x => parseInt(x),
-    level: 'atom-test', property: B.acp('atomicNumber')
+      '@desc': 'atomic element number',
+      '@examples': ['elemno=8'],
+      isNumeric: true,
+      regex: /[0-9\s{}-]+/, map: x => parseInt(x),
+      level: 'atom-test', property: B.acp('atomicNumber')
   },
   eta: {
     '@desc': 'Based on Carlos M. Duarte, Leven M. Wadley, and Anna Marie Pyle, RNA structure comparison, motif search and discovery using a reduced representation of RNA conformational space, Nucleic Acids Research, 2003, Vol. 31, No. 16 4755-4761. The parameter eta is the C4\'[i-1]-P[i]-C4\'[i]-P[i+1] dihedral angle; theta is the P[i]-C4\'[i]-P[i+1]-C4\'[i+1] dihedral angle. Both are measured on a 0-360 degree scale because they are commonly near 180 degrees. Using the commands plot PROPERTIES eta theta resno; select visible;wireframe only one can create these authors\' "RNA worm" graph.',
@@ -464,10 +440,11 @@ export const properties: PropertyDict = {
     level: 'atom-test'
   },
   resno: {
-    '@desc': 'PDB residue number, not including insertion code (see also seqcode, below)',
-    '@examples': ['resno = 100'],
-    regex: /-?[0-9]+/, map: x => parseInt(x),
-    level: 'residue-test', property: B.ammp('auth_seq_id')
+      '@desc': 'PDB residue number, not including insertion code (see also seqcode, below)',
+      '@examples': ['resno = 100'],
+      isNumeric: true,
+      regex: /-?[0-9]+/, map: x => parseInt(x),
+      level: 'residue-test', property: B.ammp('auth_seq_id')
   },
   selected: {
     '@desc': '1.0 if atom is selected; 0.0 if not',