@jdeighan/coffee-utils 11.0.33 → 11.0.35

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "11.0.33",
+	"version": "11.0.35",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -48,7 +48,7 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/exceptions": "^1.0.26",
+		"@jdeighan/exceptions": "^2.0.0",
 		"cross-env": "^7.0.3",
 		"js-yaml": "^4.1.0",
 		"n-readlines": "^1.0.1",
@@ -56,6 +56,6 @@
 		"svelte": "^3.52.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.52"
+		"@jdeighan/unit-tester": "^2.0.55"
 	}
 }

package/src/Section.coffee

@@ -1,7 +1,7 @@
 # Section.coffee
 
 import {assert, croak} from '@jdeighan/exceptions'
-import {debug} from '@jdeighan/exceptions/debug'
+import {dbg, dbgEnter, dbgReturn} from '@jdeighan/exceptions/debug'
 import {
 	pass, undef, defined, isArray, isEmpty, isFunction,
 	} from '@jdeighan/coffee-utils'
@@ -61,12 +61,12 @@ export class Section
 
 	getBlock: () ->
 
-		debug "enter Section.getBlock()"
+		dbgEnter "Section.getBlock"
 		if (@lParts.length == 0)
-			debug "return undef from Section.getBlock()"
+			dbgReturn "Section.getBlock", undef
 			return undef
 		block = toBlock(@lParts)
 		if defined(@replacer)
 			block = @replacer block
-		debug "return from Section.getBlock()", block
+		dbgReturn "Section.getBlock", block
 		return block

package/src/Section.js

@@ -6,7 +6,9 @@ import {
 } from '@jdeighan/exceptions';
 
 import {
-  debug
+  dbg,
+  dbgEnter,
+  dbgReturn
 } from '@jdeighan/exceptions/debug';
 
 import {
@@ -74,16 +76,16 @@ export var Section = class Section {
   // ..........................................................
   getBlock() {
     var block;
-    debug("enter Section.getBlock()");
+    dbgEnter("Section.getBlock");
     if (this.lParts.length === 0) {
-      debug("return undef from Section.getBlock()");
+      dbgReturn("Section.getBlock", undef);
       return undef;
     }
     block = toBlock(this.lParts);
     if (defined(this.replacer)) {
       block = this.replacer(block);
     }
-    debug("return from Section.getBlock()", block);
+    dbgReturn("Section.getBlock", block);
     return block;
   }
 

package/src/SectionMap.coffee

@@ -1,10 +1,13 @@
 # SectionMap.coffee
 
 import {
-	assert, croak, LOG, LOGVALUE, LOGTAML, debug, isTAML, fromTAML,
+	assert, croak, LOG, LOGVALUE, LOGTAML, isTAML, fromTAML,
 	} from '@jdeighan/exceptions'
 import {
-	pass, undef, def, notdef, OL, isEmpty, nonEmpty,
+	dbg, dbgEnter, dbgReturn, dbgYield, dbgResume,
+	} from '@jdeighan/exceptions/debug'
+import {
+	pass, undef, defined, notdefined, OL, isEmpty, nonEmpty,
 	isString, isHash, isArray, isUniqueTree, isNonEmptyString,
 	isNonEmptyArray, isFunction, jsType, isArrayOfStrings,
 	} from '@jdeighan/coffee-utils'
@@ -36,7 +39,7 @@ export class SectionMap
 		#     <name> can be a section name or a set name
 		#     <function> should be <block> -> <block>
 
-		debug "enter SectionMap()", tree, @hReplacers
+		dbgEnter "SectionMap", tree, @hReplacers
 
 		@checkTree tree
 		@checkReplacers @hReplacers
@@ -46,34 +49,34 @@ export class SectionMap
 
 		@init @lFullTree
 
-		debug 'hSections', @hSections
-		debug 'hSets', @hSets
-		debug "return from SectionMap()"
+		dbg 'hSections', @hSections
+		dbg 'hSets', @hSets
+		dbgReturn "SectionMap"
 
 	# ..........................................................
 
 	init: (lTree) ->
 
-		debug "enter init()", lTree
+		dbgEnter "init", lTree
 		assert isArray(lTree), "not an array"
 		assert nonEmpty(lTree), "empty array"
 
 		firstItem = lTree[0]
 		if isSetName(firstItem)
-			debug "found set name #{OL(firstItem)}"
+			dbg "found set name #{OL(firstItem)}"
 			lTree = lTree.slice(1)
 			@mkSet firstItem, lTree
 
 		for item in lTree
 			if isArray(item)
-				debug "init subtree"
+				dbg "init subtree"
 				@init item
 			else if isSectionName(item)
-				debug "mkSection #{OL(item)}"
+				dbg "mkSection #{OL(item)}"
 				@mkSection item
 			else
 				assert isString(item), "Bad item in tree: #{OL(item)}"
-		debug "return from init()"
+		dbgReturn "init"
 		return
 
 	# ..........................................................
@@ -82,7 +85,7 @@ export class SectionMap
 
 		assert isArray(lTree), "tree is not an array"
 		assert nonEmpty(lTree), "set without sections"
-		assert notdef(@hSets[name]), "set #{OL(name)} already exists"
+		assert notdefined(@hSets[name]), "set #{OL(name)} already exists"
 		@hSets[name] = lTree
 		return
 
@@ -90,7 +93,7 @@ export class SectionMap
 
 	mkSection: (name) ->
 
-		assert notdef(@hSections[name]), "duplicate section name"
+		assert notdefined(@hSections[name]), "duplicate section name"
 		@hSections[name] = new Section(name, @hReplacers[name])
 		return
 
@@ -104,19 +107,17 @@ export class SectionMap
 		#        an array of section or set names or literal strings
 		#     i.e. it should NOT contain sub-arrays
 
-		if isString(desc)
-			debug "enter SectionMap.getBlock(#{OL(desc)})"
-		else if isArrayOfStrings(desc)
-			debug "enter SectionMap.getBlock()", desc
+		if isString(desc) || isArrayOfStrings(desc)
+			dbgEnter "SectionMap.getBlock", desc
 		else
 			croak "Bad desc: #{OL(desc)}"
 
 		if isSectionName(desc)
-			debug "item is a section name"
+			dbg "item is a section name"
 			# --- a section's getBlock() applies any replacer
 			block = @section(desc).getBlock()
 		else if isSetName(desc)
-			debug "item is a set name"
+			dbg "item is a set name"
 			lBlocks = for item in @hSets[desc]
 				if isArray(item)
 					@getBlock item[0]
@@ -126,22 +127,22 @@ export class SectionMap
 					croak "Item in set #{desc} is not a string or array"
 			block = toBlock(lBlocks)
 			replacer = @hReplacers[desc]
-			debug "replacer for is #{OL(replacer)}"
-			if def(replacer)
+			dbg "replacer for is #{OL(replacer)}"
+			if defined(replacer)
 				block = replacer(block)
 		else if isString(desc)
-			debug "item is a literal string"
+			dbg "item is a literal string"
 			# --- a literal string
 			block = desc
 		else if isArray(desc)
-			debug "item is an array"
+			dbg "item is an array"
 			lBlocks = for item in desc
 				@getBlock(item)
 			block = toBlock(lBlocks)
 		else
 			croak "Bad arg: #{OL(desc)}"
 
-		debug "return from SectionMap.getBlock()", block
+		dbgReturn "SectionMap.getBlock", block
 		return block
 
 	# ..........................................................
@@ -150,22 +151,28 @@ export class SectionMap
 
 	allSections: (desc=undef) ->
 
-		debug "enter allSections()", desc
-		if notdef(desc)
+		dbgEnter "allSections", desc
+		if notdefined(desc)
 			desc = @lFullTree
 
 		if isSectionName(desc)
-			debug "is section name"
+			dbg "is section name"
+			dbgYield "allSections", @section(desc)
 			yield @section(desc)
+			dbgResume "allSections"
 		else if isSetName(desc)
-			debug "is set name"
+			dbg "is set name"
 			for name in @hSets[desc]
+				dbgYield "allSections"
 				yield from @allSections(name)
+				dbgResume "allSections"
 		else if isArray(desc)
-			debug "is array"
+			dbg "is array"
 			for item in desc
+				dbgYield "allSections"
 				yield from @allSections(item)
-		debug "return from allSections()"
+				dbgResume "allSections"
+		dbgReturn "allSections"
 		return
 
 	# ..........................................................
@@ -191,7 +198,7 @@ export class SectionMap
 	section: (name) ->
 
 		sect = @hSections[name]
-		assert def(sect), "No section named #{OL(name)}"
+		assert defined(sect), "No section named #{OL(name)}"
 		return sect
 
 	# ..........................................................
@@ -200,7 +207,7 @@ export class SectionMap
 
 		assert isSetName(name), "bad set name #{OL(name)}"
 		lSubTree = @hSets[name]
-		assert def(lSubTree), "no such set #{OL(name)}"
+		assert defined(lSubTree), "no such set #{OL(name)}"
 		return @section(lSubTree[0])
 
 	# ..........................................................
@@ -209,16 +216,16 @@ export class SectionMap
 
 		assert isSetName(name), "bad set name #{OL(name)}"
 		lSubTree = @hSets[name]
-		assert def(lSubTree), "no such set #{OL(name)}"
+		assert defined(lSubTree), "no such set #{OL(name)}"
 		return @section(lSubTree[lSubTree.length - 1])
 
 	# ..........................................................
 
 	checkTree: (tree) ->
 
-		debug "enter checkTree()"
+		dbgEnter "checkTree"
 		if isString(tree)
-			debug "tree is a string"
+			dbg "tree is a string"
 			assert isTAML(tree), "not TAML"
 			@lFullTree = fromTAML(tree)
 		else
@@ -229,7 +236,7 @@ export class SectionMap
 		if isSetName(@lFullTree[0])
 			LOGTAML 'lFullTree', @lFullTree
 			croak "tree cannot begin with a set name"
-		debug "return from checkTree()"
+		dbgReturn "checkTree"
 		return
 
 	# ..........................................................

package/src/SectionMap.js

@@ -8,16 +8,23 @@ import {
   LOG,
   LOGVALUE,
   LOGTAML,
-  debug,
   isTAML,
   fromTAML
 } from '@jdeighan/exceptions';
 
+import {
+  dbg,
+  dbgEnter,
+  dbgReturn,
+  dbgYield,
+  dbgResume
+} from '@jdeighan/exceptions/debug';
+
 import {
   pass,
   undef,
-  def,
-  notdef,
+  defined,
+  notdefined,
   OL,
   isEmpty,
   nonEmpty,
@@ -61,7 +68,7 @@ export var SectionMap = class SectionMap {
     //        should be <name> -> <function>
     //     <name> can be a section name or a set name
     //     <function> should be <block> -> <block>
-    debug("enter SectionMap()", tree, this.hReplacers);
+    dbgEnter("SectionMap", tree, this.hReplacers);
     this.checkTree(tree);
     this.checkReplacers(this.hReplacers);
     this.hSections = {}; // --- {section name: Section Object}
@@ -69,49 +76,49 @@ export var SectionMap = class SectionMap {
       ALL: this.lFullTree // --- {set name: array of parts}
     };
     this.init(this.lFullTree);
-    debug('hSections', this.hSections);
-    debug('hSets', this.hSets);
-    debug("return from SectionMap()");
+    dbg('hSections', this.hSections);
+    dbg('hSets', this.hSets);
+    dbgReturn("SectionMap");
   }
 
   // ..........................................................
   init(lTree) {
     var firstItem, i, item, len;
-    debug("enter init()", lTree);
+    dbgEnter("init", lTree);
     assert(isArray(lTree), "not an array");
     assert(nonEmpty(lTree), "empty array");
     firstItem = lTree[0];
     if (isSetName(firstItem)) {
-      debug(`found set name ${OL(firstItem)}`);
+      dbg(`found set name ${OL(firstItem)}`);
       lTree = lTree.slice(1);
       this.mkSet(firstItem, lTree);
     }
     for (i = 0, len = lTree.length; i < len; i++) {
       item = lTree[i];
       if (isArray(item)) {
-        debug("init subtree");
+        dbg("init subtree");
         this.init(item);
       } else if (isSectionName(item)) {
-        debug(`mkSection ${OL(item)}`);
+        dbg(`mkSection ${OL(item)}`);
         this.mkSection(item);
       } else {
         assert(isString(item), `Bad item in tree: ${OL(item)}`);
       }
     }
-    debug("return from init()");
+    dbgReturn("init");
   }
 
   // ..........................................................
   mkSet(name, lTree) {
     assert(isArray(lTree), "tree is not an array");
     assert(nonEmpty(lTree), "set without sections");
-    assert(notdef(this.hSets[name]), `set ${OL(name)} already exists`);
+    assert(notdefined(this.hSets[name]), `set ${OL(name)} already exists`);
     this.hSets[name] = lTree;
   }
 
   // ..........................................................
   mkSection(name) {
-    assert(notdef(this.hSections[name]), "duplicate section name");
+    assert(notdefined(this.hSections[name]), "duplicate section name");
     this.hSections[name] = new Section(name, this.hReplacers[name]);
   }
 
@@ -124,19 +131,17 @@ export var SectionMap = class SectionMap {
     //        a set name
     //        an array of section or set names or literal strings
     //     i.e. it should NOT contain sub-arrays
-    if (isString(desc)) {
-      debug(`enter SectionMap.getBlock(${OL(desc)})`);
-    } else if (isArrayOfStrings(desc)) {
-      debug("enter SectionMap.getBlock()", desc);
+    if (isString(desc) || isArrayOfStrings(desc)) {
+      dbgEnter("SectionMap.getBlock", desc);
     } else {
       croak(`Bad desc: ${OL(desc)}`);
     }
     if (isSectionName(desc)) {
-      debug("item is a section name");
+      dbg("item is a section name");
       // --- a section's getBlock() applies any replacer
       block = this.section(desc).getBlock();
     } else if (isSetName(desc)) {
-      debug("item is a set name");
+      dbg("item is a set name");
       lBlocks = (function() {
         var i, len, ref, results;
         ref = this.hSets[desc];
@@ -155,16 +160,16 @@ export var SectionMap = class SectionMap {
       }).call(this);
       block = toBlock(lBlocks);
       replacer = this.hReplacers[desc];
-      debug(`replacer for is ${OL(replacer)}`);
-      if (def(replacer)) {
+      dbg(`replacer for is ${OL(replacer)}`);
+      if (defined(replacer)) {
         block = replacer(block);
       }
     } else if (isString(desc)) {
-      debug("item is a literal string");
+      dbg("item is a literal string");
       // --- a literal string
       block = desc;
     } else if (isArray(desc)) {
-      debug("item is an array");
+      dbg("item is an array");
       lBlocks = (function() {
         var i, len, results;
         results = [];
@@ -178,7 +183,7 @@ export var SectionMap = class SectionMap {
     } else {
       croak(`Bad arg: ${OL(desc)}`);
     }
-    debug("return from SectionMap.getBlock()", block);
+    dbgReturn("SectionMap.getBlock", block);
     return block;
   }
 
@@ -187,28 +192,34 @@ export var SectionMap = class SectionMap {
   //     so only useful for isEmpty() and nonEmpty()
   * allSections(desc = undef) {
     var i, item, j, len, len1, name, ref;
-    debug("enter allSections()", desc);
-    if (notdef(desc)) {
+    dbgEnter("allSections", desc);
+    if (notdefined(desc)) {
       desc = this.lFullTree;
     }
     if (isSectionName(desc)) {
-      debug("is section name");
+      dbg("is section name");
+      dbgYield("allSections", this.section(desc));
       yield this.section(desc);
+      dbgResume("allSections");
     } else if (isSetName(desc)) {
-      debug("is set name");
+      dbg("is set name");
       ref = this.hSets[desc];
       for (i = 0, len = ref.length; i < len; i++) {
         name = ref[i];
+        dbgYield("allSections");
         yield* this.allSections(name);
+        dbgResume("allSections");
       }
     } else if (isArray(desc)) {
-      debug("is array");
+      dbg("is array");
       for (j = 0, len1 = desc.length; j < len1; j++) {
         item = desc[j];
+        dbgYield("allSections");
         yield* this.allSections(item);
+        dbgResume("allSections");
       }
     }
-    debug("return from allSections()");
+    dbgReturn("allSections");
   }
 
   // ..........................................................
@@ -239,7 +250,7 @@ export var SectionMap = class SectionMap {
   section(name) {
     var sect;
     sect = this.hSections[name];
-    assert(def(sect), `No section named ${OL(name)}`);
+    assert(defined(sect), `No section named ${OL(name)}`);
     return sect;
   }
 
@@ -248,7 +259,7 @@ export var SectionMap = class SectionMap {
     var lSubTree;
     assert(isSetName(name), `bad set name ${OL(name)}`);
     lSubTree = this.hSets[name];
-    assert(def(lSubTree), `no such set ${OL(name)}`);
+    assert(defined(lSubTree), `no such set ${OL(name)}`);
     return this.section(lSubTree[0]);
   }
 
@@ -257,15 +268,15 @@ export var SectionMap = class SectionMap {
     var lSubTree;
     assert(isSetName(name), `bad set name ${OL(name)}`);
     lSubTree = this.hSets[name];
-    assert(def(lSubTree), `no such set ${OL(name)}`);
+    assert(defined(lSubTree), `no such set ${OL(name)}`);
     return this.section(lSubTree[lSubTree.length - 1]);
   }
 
   // ..........................................................
   checkTree(tree) {
-    debug("enter checkTree()");
+    dbgEnter("checkTree");
     if (isString(tree)) {
-      debug("tree is a string");
+      dbg("tree is a string");
       assert(isTAML(tree), "not TAML");
       this.lFullTree = fromTAML(tree);
     } else {
@@ -277,7 +288,7 @@ export var SectionMap = class SectionMap {
       LOGTAML('lFullTree', this.lFullTree);
       croak("tree cannot begin with a set name");
     }
-    debug("return from checkTree()");
+    dbgReturn("checkTree");
   }
 
   // ..........................................................

package/src/fs.coffee

@@ -5,7 +5,8 @@ import urllib from 'url'
 import fs from 'fs'
 import NReadLines from 'n-readlines'
 
-import {assert, croak, debug, LOG, fromTAML} from '@jdeighan/exceptions'
+import {assert, croak, LOG, fromTAML} from '@jdeighan/exceptions'
+import {dbg, dbgEnter, dbgReturn} from '@jdeighan/exceptions/debug'
 import {
 	undef, pass, defined, rtrim, isEmpty, nonEmpty, getOptions,
 	isString, isArray, isHash, isRegExp, isFunction, OL,
@@ -377,7 +378,7 @@ export parseSource = (source) ->
 	#        }
 	# --- NOTE: source may be a file URL, e.g. import.meta.url
 
-	debug "enter parseSource(#{OL(source)})"
+	dbgEnter "parseSource", source
 	assert isString(source),\
 			"parseSource(): source not a string: #{OL(source)}"
 	if source == 'unit test'
@@ -414,7 +415,7 @@ export parseSource = (source) ->
 				([A-Za-z_]+)
 				$///)
 			hSourceInfo.purpose = lMatches[1]
-	debug "return from parseSource()", hSourceInfo
+	dbgReturn "parseSource", hSourceInfo
 	return hSourceInfo
 
 # ---------------------------------------------------------------------------

package/src/fs.js

@@ -13,11 +13,16 @@ import NReadLines from 'n-readlines';
 import {
   assert,
   croak,
-  debug,
   LOG,
   fromTAML
 } from '@jdeighan/exceptions';
 
+import {
+  dbg,
+  dbgEnter,
+  dbgReturn
+} from '@jdeighan/exceptions/debug';
+
 import {
   undef,
   pass,
@@ -447,7 +452,7 @@ export var parseSource = function(source) {
   //        purpose
   //        }
   // --- NOTE: source may be a file URL, e.g. import.meta.url
-  debug(`enter parseSource(${OL(source)})`);
+  dbgEnter("parseSource", source);
   assert(isString(source), `parseSource(): source not a string: ${OL(source)}`);
   if (source === 'unit test') {
     croak("A source of 'unit test' is deprecated");
@@ -483,7 +488,7 @@ export var parseSource = function(source) {
       hSourceInfo.purpose = lMatches[1];
     }
   }
-  debug("return from parseSource()", hSourceInfo);
+  dbgReturn("parseSource", hSourceInfo);
   return hSourceInfo;
 };
 

package/src/fsa.coffee

@@ -2,7 +2,7 @@
 
 import {assert, croak} from '@jdeighan/exceptions'
 import {LOG} from '@jdeighan/exceptions/log'
-import {debug} from '@jdeighan/exceptions/debug'
+import {dbg, dbgEnter, dbgReturn} from '@jdeighan/exceptions/debug'
 import {
 	undef, defined, notdefined, words, isEmpty, nonEmpty,
 	isString, OL,
@@ -15,13 +15,13 @@ export class FSA
 
 	constructor: (block) ->
 
-		debug "enter FSA()"
+		dbgEnter "FSA", block
 		assert isString(block), "block not a string"
 		@hTransitions = {}
 		lLines = toArray(block, 'noEmptyLines')
-		debug 'lLines', lLines
+		dbg 'lLines', lLines
 		for line,i in lLines
-			debug "LINE #{i}", line
+			dbg "LINE #{i}", line
 			lWords = words(line)
 			if (lWords.length == 3)
 				[bState, token, eState] = lWords
@@ -30,7 +30,7 @@ export class FSA
 				[bState, token, eState, output] = lWords
 			else
 				croak "Invalid desc: #{OL(line)}"
-			debug "LINE #{i}: #{OL(bState)} #{OL(token)} #{OL(eState)} #{OL(output)}"
+			dbg "LINE #{i}: #{OL(bState)} #{OL(token)} #{OL(eState)} #{OL(output)}"
 			assert nonEmpty(eState), "Invalid FSA description #{i}"
 
 			# --- tokens may be quoted (but may not contain whitespace),
@@ -38,7 +38,7 @@ export class FSA
 			if (i == 0)
 				assert (bState == 'start'), "Invalid FSA description #{i}"
 			token = @fixToken(token)
-			debug 'token', token
+			dbg 'token', token
 			if isEmpty(output)
 				output = undef
 			hTrans = @hTransitions[bState]
@@ -46,9 +46,9 @@ export class FSA
 				hTrans = @hTransitions[bState] = {}
 			assert notdefined(hTrans[token]), "Duplicate transition"
 			hTrans[token] = [eState, output]
-		debug 'hTransitions', @hTransitions
+		dbg 'hTransitions', @hTransitions
 		@curState = 'start'
-		debug "return from FSA()"
+		dbgReturn "FSA"
 
 	# ..........................................................
 

package/src/fsa.js

@@ -10,7 +10,9 @@ import {
 } from '@jdeighan/exceptions/log';
 
 import {
-  debug
+  dbg,
+  dbgEnter,
+  dbgReturn
 } from '@jdeighan/exceptions/debug';
 
 import {
@@ -32,14 +34,14 @@ import {
 export var FSA = class FSA {
   constructor(block) {
     var bState, eState, hTrans, i, j, lLines, lWords, len, line, output, token;
-    debug("enter FSA()");
+    dbgEnter("FSA", block);
     assert(isString(block), "block not a string");
     this.hTransitions = {};
     lLines = toArray(block, 'noEmptyLines');
-    debug('lLines', lLines);
+    dbg('lLines', lLines);
     for (i = j = 0, len = lLines.length; j < len; i = ++j) {
       line = lLines[i];
-      debug(`LINE ${i}`, line);
+      dbg(`LINE ${i}`, line);
       lWords = words(line);
       if (lWords.length === 3) {
         [bState, token, eState] = lWords;
@@ -49,7 +51,7 @@ export var FSA = class FSA {
       } else {
         croak(`Invalid desc: ${OL(line)}`);
       }
-      debug(`LINE ${i}: ${OL(bState)} ${OL(token)} ${OL(eState)} ${OL(output)}`);
+      dbg(`LINE ${i}: ${OL(bState)} ${OL(token)} ${OL(eState)} ${OL(output)}`);
       assert(nonEmpty(eState), `Invalid FSA description ${i}`);
       // --- tokens may be quoted (but may not contain whitespace),
       //     but the quotes are stripped
@@ -57,7 +59,7 @@ export var FSA = class FSA {
         assert(bState === 'start', `Invalid FSA description ${i}`);
       }
       token = this.fixToken(token);
-      debug('token', token);
+      dbg('token', token);
       if (isEmpty(output)) {
         output = undef;
       }
@@ -68,9 +70,9 @@ export var FSA = class FSA {
       assert(notdefined(hTrans[token]), "Duplicate transition");
       hTrans[token] = [eState, output];
     }
-    debug('hTransitions', this.hTransitions);
+    dbg('hTransitions', this.hTransitions);
     this.curState = 'start';
-    debug("return from FSA()");
+    dbgReturn("FSA");
   }
 
   // ..........................................................

package/src/utils.coffee

@@ -3,20 +3,20 @@
 import {assert, croak} from '@jdeighan/exceptions'
 import {LOG, sep_dash, sep_eq} from '@jdeighan/exceptions/log'
 import {
-	undef, pass, def, defined, notdef, notdefined,
+	undef, pass, defined, notdefined,
 	deepCopy, escapeStr, unescapeStr, hasChar, quoted, OL,
 	isString, isNumber, isInteger, isHash, isArray, isBoolean,
 	isConstructor, isFunction, isRegExp, isObject, getClassName,
-	jsType,
+	jsType, oneof,
 	isEmpty, nonEmpty, chomp, rtrim, setCharsAt, words, getOptions,
 	} from '@jdeighan/exceptions/utils'
 
 export {
-	undef, pass, def, defined, notdef, notdefined, LOG, sep_dash, sep_eq,
+	undef, pass, defined, notdefined, LOG, sep_dash, sep_eq,
 	deepCopy, escapeStr, unescapeStr, hasChar, quoted, OL,
 	isString, isNumber, isInteger, isHash, isArray, isBoolean,
 	isConstructor, isFunction, isRegExp, isObject, getClassName,
-	jsType,
+	jsType, oneof,
 	isEmpty, nonEmpty, chomp, rtrim, setCharsAt, words, getOptions,
 	}
 
@@ -68,12 +68,6 @@ export charCount = (str, ch) ->
 
 # ---------------------------------------------------------------------------
 
-export oneof = (word, lWords...) ->
-
-	return (lWords.indexOf(word) >= 0)
-
-# ---------------------------------------------------------------------------
-
 export removeKeys = (h, lKeys) =>
 
 	for key in lKeys

package/src/utils.js

@@ -16,9 +16,7 @@ import {
 import {
   undef,
   pass,
-  def,
   defined,
-  notdef,
   notdefined,
   deepCopy,
   escapeStr,
@@ -38,6 +36,7 @@ import {
   isObject,
   getClassName,
   jsType,
+  oneof,
   isEmpty,
   nonEmpty,
   chomp,
@@ -50,9 +49,7 @@ import {
 export {
   undef,
   pass,
-  def,
   defined,
-  notdef,
   notdefined,
   LOG,
   sep_dash,
@@ -75,6 +72,7 @@ export {
   isObject,
   getClassName,
   jsType,
+  oneof,
   isEmpty,
   nonEmpty,
   chomp,
@@ -125,11 +123,6 @@ export var charCount = function(str, ch) {
   return count;
 };
 
-// ---------------------------------------------------------------------------
-export var oneof = function(word, ...lWords) {
-  return lWords.indexOf(word) >= 0;
-};
-
 // ---------------------------------------------------------------------------
 export var removeKeys = (h, lKeys) => {
   var i, item, j, key, len, len1, value;