@jdeighan/coffee-utils 14.0.2 → 14.0.4

package/package.json

@@ -1,11 +1,10 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "14.0.2",
+	"version": "14.0.4",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
-		".": "./src/coffee-utils.js",
 		"./server": "./src/server.js",
 		"./browser": "./src/browser.js",
 		"./fs": "./src/fs.js",
@@ -50,13 +49,13 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^3.0.3",
+		"@jdeighan/base-utils": "^4.0.1",
 		"cross-env": "^7.0.3",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
 		"svelte": "^3.55.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^3.0.16"
+		"@jdeighan/unit-tester": "^3.0.18"
 	}
 }

package/src/KeyedSet.coffee

@@ -3,14 +3,13 @@
 import {
 	undef, defined, notdefined, OL, deepCopy,
 	isString, isNonEmptyString, isArray, isHash,
-	isEmpty, nonEmpty,
+	isEmpty, nonEmpty, isArrayOfStrings,
 	} from '@jdeighan/base-utils'
 import {assert, croak} from '@jdeighan/base-utils/exceptions'
 import {LOG, LOGVALUE} from '@jdeighan/base-utils/log'
 import {
 	dbgEnter, dbgReturn, dbg,
 	} from '@jdeighan/base-utils/debug'
-import {isArrayOfStrings} from '@jdeighan/coffee-utils'
 
 # ---------------------------------------------------------------------------
 

package/src/KeyedSet.js

@@ -11,7 +11,8 @@ import {
   isArray,
   isHash,
   isEmpty,
-  nonEmpty
+  nonEmpty,
+  isArrayOfStrings
 } from '@jdeighan/base-utils';
 
 import {
@@ -30,10 +31,6 @@ import {
   dbg
 } from '@jdeighan/base-utils/debug';
 
-import {
-  isArrayOfStrings
-} from '@jdeighan/coffee-utils';
-
 // ---------------------------------------------------------------------------
 export var KeyedSet = class KeyedSet extends Map {
   constructor(setName, lKeyNames, sep = '|') {

package/src/SectionMap.coffee

@@ -1,19 +1,17 @@
 # SectionMap.coffee
 
-import {assert, croak} from '@jdeighan/base-utils/exceptions'
-import {LOG, LOGVALUE, LOGTAML} from '@jdeighan/base-utils/log'
-import {isTAML, fromTAML} from '@jdeighan/base-utils/taml'
-import {
-	dbg, dbgEnter, dbgReturn, dbgYield, dbgResume,
-	} from '@jdeighan/base-utils/debug'
 import {
 	pass, undef, defined, notdefined, OL, isEmpty, nonEmpty,
 	isString, isHash, isArray, isNonEmptyString,
-	isFunction, jsType, toBlock,
+	isFunction, jsType, toBlock, isArrayOfStrings, isNonEmptyArray,
 	} from '@jdeighan/base-utils'
+import {assert, croak} from '@jdeighan/base-utils/exceptions'
+import {LOG, LOGVALUE, LOGTAML} from '@jdeighan/base-utils/log'
 import {
-	isArrayOfStrings, isNonEmptyArray, isUniqueTree,
-	} from '@jdeighan/coffee-utils'
+	dbg, dbgEnter, dbgReturn, dbgYield, dbgResume,
+	} from '@jdeighan/base-utils/debug'
+import {isTAML, fromTAML} from '@jdeighan/base-utils/taml'
+
 import {Section} from '@jdeighan/coffee-utils/section'
 
 # ---------------------------------------------------------------------------

package/src/SectionMap.js

@@ -2,6 +2,25 @@
 // SectionMap.coffee
 var isSectionName, isSetName;
 
+import {
+  pass,
+  undef,
+  defined,
+  notdefined,
+  OL,
+  isEmpty,
+  nonEmpty,
+  isString,
+  isHash,
+  isArray,
+  isNonEmptyString,
+  isFunction,
+  jsType,
+  toBlock,
+  isArrayOfStrings,
+  isNonEmptyArray
+} from '@jdeighan/base-utils';
+
 import {
   assert,
   croak
@@ -13,11 +32,6 @@ import {
   LOGTAML
 } from '@jdeighan/base-utils/log';
 
-import {
-  isTAML,
-  fromTAML
-} from '@jdeighan/base-utils/taml';
-
 import {
   dbg,
   dbgEnter,
@@ -27,27 +41,9 @@ import {
 } from '@jdeighan/base-utils/debug';
 
 import {
-  pass,
-  undef,
-  defined,
-  notdefined,
-  OL,
-  isEmpty,
-  nonEmpty,
-  isString,
-  isHash,
-  isArray,
-  isNonEmptyString,
-  isFunction,
-  jsType,
-  toBlock
-} from '@jdeighan/base-utils';
-
-import {
-  isArrayOfStrings,
-  isNonEmptyArray,
-  isUniqueTree
-} from '@jdeighan/coffee-utils';
+  isTAML,
+  fromTAML
+} from '@jdeighan/base-utils/taml';
 
 import {
   Section

package/src/block.coffee

@@ -5,10 +5,9 @@ import readline from 'readline'
 
 import {assert, croak} from '@jdeighan/base-utils/exceptions'
 import {
-	undef, pass, defined, notdefined, rtrim, OL,
+	undef, pass, defined, notdefined, rtrim, OL, isArrayOfStrings,
 	isEmpty, isString, isArray, nonEmpty, toArray, toBlock,
 	} from '@jdeighan/base-utils'
-import {isArrayOfStrings} from '@jdeighan/coffee-utils'
 
 # ---------------------------------------------------------------------------
 

package/src/block.js

@@ -16,6 +16,7 @@ import {
   notdefined,
   rtrim,
   OL,
+  isArrayOfStrings,
   isEmpty,
   isString,
   isArray,
@@ -24,10 +25,6 @@ import {
   toBlock
 } from '@jdeighan/base-utils';
 
-import {
-  isArrayOfStrings
-} from '@jdeighan/coffee-utils';
-
 // ---------------------------------------------------------------------------
 export var splitBlock = function(block) {
   var pos;

package/src/indent.coffee

@@ -152,7 +152,7 @@ export undented = (input, level=undef, oneIndent="\t") ->
 			lNewLines.push('')
 		else
 			if (line.indexOf(toRemove) != 0)
-				throw new Error("remove #{OL(toRemove)} from #{OL(text)}")
+				throw new Error("remove #{OL(toRemove)} from #{OL(line)}")
 			lNewLines.push(line.substr(nToRemove))
 
 	if isString(input)
@@ -160,36 +160,6 @@ export undented = (input, level=undef, oneIndent="\t") ->
 	else
 		return lNewLines
 
-# ---------------------------------------------------------------------------
-#    tabify - convert leading spaces to TAB characters
-#             if numSpaces is not defined, then the first line
-#             that contains at least one space sets it
-
-export tabify = (str, numSpaces=undef) ->
-
-	lLines = []
-	for str in toArray(str)
-		[_, prefix, theRest] = str.match(/^(\s*)(.*)$/)
-		prefixLen = prefix.length
-		if prefixLen == 0
-			lLines.push theRest
-		else
-			assert (prefix.indexOf('\t') == -1), "found TAB"
-			if numSpaces == undef
-				numSpaces = prefixLen
-			assert (prefixLen % numSpaces == 0), "Bad prefix"
-			level = prefixLen / numSpaces
-			lLines.push '\t'.repeat(level) + theRest
-	result = toBlock(lLines)
-	return result
-
-# ---------------------------------------------------------------------------
-#    untabify - convert ALL TABs to spaces
-
-export untabify = (str, numSpaces=3) ->
-
-	return str.replace(/\t/g, ' '.repeat(numSpaces))
-
 # ---------------------------------------------------------------------------
 #    enclose - indent text, surround with pre and post
 

package/src/indent.js

@@ -171,7 +171,7 @@ export var undented = function(input, level = undef, oneIndent = "\t") {
       lNewLines.push('');
     } else {
       if (line.indexOf(toRemove) !== 0) {
-        throw new Error(`remove ${OL(toRemove)} from ${OL(text)}`);
+        throw new Error(`remove ${OL(toRemove)} from ${OL(line)}`);
       }
       lNewLines.push(line.substr(nToRemove));
     }
@@ -183,40 +183,6 @@ export var undented = function(input, level = undef, oneIndent = "\t") {
   }
 };
 
-// ---------------------------------------------------------------------------
-//    tabify - convert leading spaces to TAB characters
-//             if numSpaces is not defined, then the first line
-//             that contains at least one space sets it
-export var tabify = function(str, numSpaces = undef) {
-  var _, i, lLines, len1, level, prefix, prefixLen, ref, result, theRest;
-  lLines = [];
-  ref = toArray(str);
-  for (i = 0, len1 = ref.length; i < len1; i++) {
-    str = ref[i];
-    [_, prefix, theRest] = str.match(/^(\s*)(.*)$/);
-    prefixLen = prefix.length;
-    if (prefixLen === 0) {
-      lLines.push(theRest);
-    } else {
-      assert(prefix.indexOf('\t') === -1, "found TAB");
-      if (numSpaces === undef) {
-        numSpaces = prefixLen;
-      }
-      assert(prefixLen % numSpaces === 0, "Bad prefix");
-      level = prefixLen / numSpaces;
-      lLines.push('\t'.repeat(level) + theRest);
-    }
-  }
-  result = toBlock(lLines);
-  return result;
-};
-
-// ---------------------------------------------------------------------------
-//    untabify - convert ALL TABs to spaces
-export var untabify = function(str, numSpaces = 3) {
-  return str.replace(/\t/g, ' '.repeat(numSpaces));
-};
-
 // ---------------------------------------------------------------------------
 //    enclose - indent text, surround with pre and post
 export var enclose = function(text, pre, post, oneIndent = "\t") {

package/src/coffee-utils.coffee

@@ -1,351 +0,0 @@
-# coffee-utils.coffee
-
-import {
-	undef, pass, defined, notdefined,
-	deepCopy, escapeStr, unescapeStr, hasChar, quoted, OL,
-	isString, isNumber, isInteger, isHash, isArray, isBoolean,
-	isConstructor, isFunction, isRegExp, isObject, getClassName,
-	jsType, oneof, isIterable,
-	isEmpty, nonEmpty, chomp, rtrim, setCharsAt, words, getOptions,
-	} from '@jdeighan/base-utils'
-import {assert, croak} from '@jdeighan/base-utils/exceptions'
-import {
-	LOG, LOGVALUE, sep_dash, sep_eq,
-	} from '@jdeighan/base-utils/log'
-import {
-	dbgEnter, dbgReturn, dbgYield, dbgResume, dbg, setDebugging,
-	} from '@jdeighan/base-utils/debug'
-
-# ---------------------------------------------------------------------------
-
-export isHashComment = (line) =>
-
-	lMatches = line.match(///^
-			\s*
-			\#
-			(\s|$)
-			///)
-	return defined(lMatches)
-
-# ---------------------------------------------------------------------------
-
-export isSubclassOf = (subClass, superClass) ->
-
-	return (subClass == superClass) \
-		|| (subClass.prototype instanceof superClass)
-
-# ---------------------------------------------------------------------------
-
-export eval_expr = (str) ->
-
-	str = str.replace(/\bundef\b/g, 'undefined')
-	return Function('"use strict";return (' + str + ')')();
-
-# ---------------------------------------------------------------------------
-
-export patchStr = (bigstr, pos, str) ->
-
-	endpos = pos + str.length
-	if (endpos < bigstr.length)
-		return bigstr.substring(0, pos) + str + bigstr.substring(endpos)
-	else
-		return bigstr.substring(0, pos) + str
-
-# ---------------------------------------------------------------------------
-
-export charCount = (str, ch) ->
-
-	count = 0
-	pos = str.indexOf(ch, 0)
-	while (pos >= 0)
-		count += 1
-		pos = str.indexOf(ch, pos+1)
-	return count
-
-# ---------------------------------------------------------------------------
-
-export removeKeys = (h, lKeys) =>
-
-	for key in lKeys
-		delete h[key]
-	for own key,value of h
-		if defined(value)
-			if isArray(value)
-				for item in value
-					if isHash(item)
-						removeKeys(item, lKeys)
-			else if (typeof value == 'object')
-				removeKeys value, lKeys
-	return
-
-# ---------------------------------------------------------------------------
-
-export isNonEmptyString = (x) ->
-
-	if typeof x != 'string' && x ! instanceof String
-		return false
-	if x.match(/^\s*$/)
-		return false
-	return true
-
-# ---------------------------------------------------------------------------
-
-export isNonEmptyArray = (x) ->
-
-	return isArray(x) && (x.length > 0)
-
-# ---------------------------------------------------------------------------
-
-export isNonEmptyHash = (x) ->
-
-	return isHash(x) && (Object.keys(x).length > 0)
-
-# ---------------------------------------------------------------------------
-
-export hashHasKey = (x, key) ->
-
-	assert isHash(x), "hashHasKey(): not a hash"
-	assert isString(key), "hashHasKey(): key not a string"
-	return x.hasOwnProperty(key)
-
-# ---------------------------------------------------------------------------
-
-export notInArray = (lItems, item) ->
-
-	return (lItems.indexOf(item) == -1)
-
-# ---------------------------------------------------------------------------
-
-export pushCond = (lItems, item, doPush=notInArray) ->
-
-	if doPush(lItems, item)
-		lItems.push item
-		return true
-	else
-		return false
-
-# ---------------------------------------------------------------------------
-
-export isArrayOfHashes = (lItems) ->
-	# --- undefined items are allowed
-
-	if ! isArray(lItems)
-		return false
-	for item in lItems
-		if defined(item) && ! isHash(item)
-			return false
-	return true
-
-# ---------------------------------------------------------------------------
-
-export isArrayOfStrings = (lItems) ->
-	# --- undefined items are allowed
-
-	if ! isArray(lItems)
-		return false
-	for item in lItems
-		if defined(item) && ! isString(item)
-			return false
-	return true
-
-# ---------------------------------------------------------------------------
-
-export isUniqueList = (lItems, func=undef) ->
-
-	if notdefined(lItems)
-		return true     # empty list is unique
-	if defined(func)
-		assert isFunction(func), "Not a function: #{OL(func)}"
-	h = {}
-	for item in lItems
-		if defined(func) && !func(item)
-			return false
-		if defined(h[item])
-			return false
-		h[item] = 1
-	return true
-
-# ---------------------------------------------------------------------------
-
-export isUniqueTree = (lItems, func=undef, hFound={}) ->
-
-	if isEmpty(lItems)
-		return true     # empty list is unique
-	if defined(func)
-		assert isFunction(func), "Not a function: #{OL(func)}"
-	for item in lItems
-		if isArray(item)
-			if ! isUniqueTree(item, func, hFound)
-				return false
-		else
-			if defined(func) && !func(item)
-				return false
-			if defined(hFound[item])
-				return false
-			hFound[item] = 1
-	return true
-
-# ---------------------------------------------------------------------------
-
-export uniq = (lItems) ->
-
-	return [...new Set(lItems)]
-
-# ---------------------------------------------------------------------------
-#   warn - issue a warning
-
-export warn = (message) ->
-
-	say "WARNING: #{message}"
-
-# ---------------------------------------------------------------------------
-#   hashToStr - stringify a hash
-
-export hashToStr = (h) ->
-
-	return JSON.stringify(h, Object.keys(h).sort(), 3)
-
-# ---------------------------------------------------------------------------
-#   say - print to the console (for now)
-#         later, on a web page, call alert(str)
-
-export say = (x) ->
-
-	if isHash(x)
-		LOG hashToStr(x)
-	else
-		LOG x
-	return
-
-# ---------------------------------------------------------------------------
-
-export titleLine = (title, char='=', padding=2, linelen=42) ->
-	# --- used in logger
-
-	if ! title
-		return char.repeat(linelen)
-
-	titleLen = title.length + 2 * padding
-	nLeft = Math.floor((linelen - titleLen) / 2)
-	nRight = linelen - nLeft - titleLen
-	strLeft = char.repeat(nLeft)
-	strMiddle = ' '.repeat(padding) + title + ' '.repeat(padding)
-	strRight = char.repeat(nRight)
-	return strLeft + strMiddle + strRight
-
-# ---------------------------------------------------------------------------
-#   rtrunc - strip nChars chars from right of a string
-
-export rtrunc = (str, nChars) ->
-
-	return str.substring(0, str.length - nChars)
-
-# ---------------------------------------------------------------------------
-#   ltrunc - strip nChars chars from left of a string
-
-export ltrunc = (str, nChars) ->
-
-	return str.substring(nChars)
-
-# ---------------------------------------------------------------------------
-
-export removeCR = (str) ->
-
-	return str.replace(/\r/g, '')
-
-# ---------------------------------------------------------------------------
-
-export CWS = (str) ->
-
-	assert isString(str), "CWS(): parameter not a string"
-	return str.trim().replace(/\s+/sg, ' ')
-
-# ---------------------------------------------------------------------------
-
-export extractMatches = (line, regexp, convertFunc=undef) ->
-
-	lStrings = [...line.matchAll(regexp)]
-	lStrings = for str in lStrings
-		str[0]
-	if defined(convertFunc)
-		lConverted = for str in lStrings
-			convertFunc(str)
-		return lConverted
-	else
-		return lStrings
-
-# ---------------------------------------------------------------------------
-
-export envVarsWithPrefix = (prefix, hOptions={}) ->
-	# --- valid options:
-	#        stripPrefix
-
-	assert prefix, "envVarsWithPrefix: empty prefix!"
-	plen = prefix.length
-	h = {}
-	for key in Object.keys(process.env)
-		if key.indexOf(prefix) == 0
-			if hOptions.stripPrefix
-				h[key.substr(plen)] = process.env[key]
-			else
-				h[key] = process.env[key]
-	return h
-
-# ---------------------------------------------------------------------------
-
-export getTimeStr = (date=undef) ->
-
-	if date == undef
-		date = new Date()
-	return date.toLocaleTimeString('en-US')
-
-# ---------------------------------------------------------------------------
-
-export getDateStr = (date=undef) ->
-
-	if date == undef
-		date = new Date()
-	return date.toLocaleDateString('en-US')
-
-# ---------------------------------------------------------------------------
-
-export strcat = (lItems...) ->
-	str = ''
-	for item in lItems
-		str += item.toString()
-	return str
-
-# ---------------------------------------------------------------------------
-
-export replaceVars = (line, hVars={}, rx=/__(env\.)?([A-Za-z_]\w*)__/g) ->
-
-	assert isHash(hVars), "replaceVars() hVars is not a hash"
-
-	replacerFunc = (match, prefix, name) =>
-		if prefix
-			return process.env[name]
-		else
-			value = hVars[name]
-			if defined(value)
-				if isString(value)
-					return value
-				else
-					return JSON.stringify(value)
-			else
-				return "__#{name}__"
-	return line.replace(rx, replacerFunc)
-
-# ---------------------------------------------------------------------------
-
-export className = (aClass) ->
-
-	if lMatches = aClass.toString().match(/class\s+(\w+)/)
-		return lMatches[1]
-	else
-		croak "className(): Bad input class"
-
-# ---------------------------------------------------------------------------
-
-export timestamp = () ->
-
-	return new Date().toLocaleTimeString("en-US")

package/src/coffee-utils.js

@@ -1,431 +0,0 @@
-// Generated by CoffeeScript 2.7.0
-// coffee-utils.coffee
-var hasProp = {}.hasOwnProperty;
-
-import {
-  undef,
-  pass,
-  defined,
-  notdefined,
-  deepCopy,
-  escapeStr,
-  unescapeStr,
-  hasChar,
-  quoted,
-  OL,
-  isString,
-  isNumber,
-  isInteger,
-  isHash,
-  isArray,
-  isBoolean,
-  isConstructor,
-  isFunction,
-  isRegExp,
-  isObject,
-  getClassName,
-  jsType,
-  oneof,
-  isIterable,
-  isEmpty,
-  nonEmpty,
-  chomp,
-  rtrim,
-  setCharsAt,
-  words,
-  getOptions
-} from '@jdeighan/base-utils';
-
-import {
-  assert,
-  croak
-} from '@jdeighan/base-utils/exceptions';
-
-import {
-  LOG,
-  LOGVALUE,
-  sep_dash,
-  sep_eq
-} from '@jdeighan/base-utils/log';
-
-import {
-  dbgEnter,
-  dbgReturn,
-  dbgYield,
-  dbgResume,
-  dbg,
-  setDebugging
-} from '@jdeighan/base-utils/debug';
-
-// ---------------------------------------------------------------------------
-export var isHashComment = (line) => {
-  var lMatches;
-  lMatches = line.match(/^\s*\#(\s|$)/);
-  return defined(lMatches);
-};
-
-// ---------------------------------------------------------------------------
-export var isSubclassOf = function(subClass, superClass) {
-  return (subClass === superClass) || (subClass.prototype instanceof superClass);
-};
-
-// ---------------------------------------------------------------------------
-export var eval_expr = function(str) {
-  str = str.replace(/\bundef\b/g, 'undefined');
-  return Function('"use strict";return (' + str + ')')();
-};
-
-// ---------------------------------------------------------------------------
-export var patchStr = function(bigstr, pos, str) {
-  var endpos;
-  endpos = pos + str.length;
-  if (endpos < bigstr.length) {
-    return bigstr.substring(0, pos) + str + bigstr.substring(endpos);
-  } else {
-    return bigstr.substring(0, pos) + str;
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var charCount = function(str, ch) {
-  var count, pos;
-  count = 0;
-  pos = str.indexOf(ch, 0);
-  while (pos >= 0) {
-    count += 1;
-    pos = str.indexOf(ch, pos + 1);
-  }
-  return count;
-};
-
-// ---------------------------------------------------------------------------
-export var removeKeys = (h, lKeys) => {
-  var i, item, j, key, len, len1, value;
-  for (i = 0, len = lKeys.length; i < len; i++) {
-    key = lKeys[i];
-    delete h[key];
-  }
-  for (key in h) {
-    if (!hasProp.call(h, key)) continue;
-    value = h[key];
-    if (defined(value)) {
-      if (isArray(value)) {
-        for (j = 0, len1 = value.length; j < len1; j++) {
-          item = value[j];
-          if (isHash(item)) {
-            removeKeys(item, lKeys);
-          }
-        }
-      } else if (typeof value === 'object') {
-        removeKeys(value, lKeys);
-      }
-    }
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var isNonEmptyString = function(x) {
-  if (typeof x !== 'string' && !(x instanceof String)) {
-    return false;
-  }
-  if (x.match(/^\s*$/)) {
-    return false;
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var isNonEmptyArray = function(x) {
-  return isArray(x) && (x.length > 0);
-};
-
-// ---------------------------------------------------------------------------
-export var isNonEmptyHash = function(x) {
-  return isHash(x) && (Object.keys(x).length > 0);
-};
-
-// ---------------------------------------------------------------------------
-export var hashHasKey = function(x, key) {
-  assert(isHash(x), "hashHasKey(): not a hash");
-  assert(isString(key), "hashHasKey(): key not a string");
-  return x.hasOwnProperty(key);
-};
-
-// ---------------------------------------------------------------------------
-export var notInArray = function(lItems, item) {
-  return lItems.indexOf(item) === -1;
-};
-
-// ---------------------------------------------------------------------------
-export var pushCond = function(lItems, item, doPush = notInArray) {
-  if (doPush(lItems, item)) {
-    lItems.push(item);
-    return true;
-  } else {
-    return false;
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var isArrayOfHashes = function(lItems) {
-  var i, item, len;
-  if (!isArray(lItems)) {
-    return false;
-  }
-  for (i = 0, len = lItems.length; i < len; i++) {
-    item = lItems[i];
-    if (defined(item) && !isHash(item)) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var isArrayOfStrings = function(lItems) {
-  var i, item, len;
-  if (!isArray(lItems)) {
-    return false;
-  }
-  for (i = 0, len = lItems.length; i < len; i++) {
-    item = lItems[i];
-    if (defined(item) && !isString(item)) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var isUniqueList = function(lItems, func = undef) {
-  var h, i, item, len;
-  if (notdefined(lItems)) {
-    return true; // empty list is unique
-  }
-  if (defined(func)) {
-    assert(isFunction(func), `Not a function: ${OL(func)}`);
-  }
-  h = {};
-  for (i = 0, len = lItems.length; i < len; i++) {
-    item = lItems[i];
-    if (defined(func) && !func(item)) {
-      return false;
-    }
-    if (defined(h[item])) {
-      return false;
-    }
-    h[item] = 1;
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var isUniqueTree = function(lItems, func = undef, hFound = {}) {
-  var i, item, len;
-  if (isEmpty(lItems)) {
-    return true; // empty list is unique
-  }
-  if (defined(func)) {
-    assert(isFunction(func), `Not a function: ${OL(func)}`);
-  }
-  for (i = 0, len = lItems.length; i < len; i++) {
-    item = lItems[i];
-    if (isArray(item)) {
-      if (!isUniqueTree(item, func, hFound)) {
-        return false;
-      }
-    } else {
-      if (defined(func) && !func(item)) {
-        return false;
-      }
-      if (defined(hFound[item])) {
-        return false;
-      }
-      hFound[item] = 1;
-    }
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var uniq = function(lItems) {
-  return [...new Set(lItems)];
-};
-
-// ---------------------------------------------------------------------------
-//   warn - issue a warning
-export var warn = function(message) {
-  return say(`WARNING: ${message}`);
-};
-
-// ---------------------------------------------------------------------------
-//   hashToStr - stringify a hash
-export var hashToStr = function(h) {
-  return JSON.stringify(h, Object.keys(h).sort(), 3);
-};
-
-// ---------------------------------------------------------------------------
-//   say - print to the console (for now)
-//         later, on a web page, call alert(str)
-export var say = function(x) {
-  if (isHash(x)) {
-    LOG(hashToStr(x));
-  } else {
-    LOG(x);
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var titleLine = function(title, char = '=', padding = 2, linelen = 42) {
-  var nLeft, nRight, strLeft, strMiddle, strRight, titleLen;
-  if (!title) {
-    return char.repeat(linelen);
-  }
-  titleLen = title.length + 2 * padding;
-  nLeft = Math.floor((linelen - titleLen) / 2);
-  nRight = linelen - nLeft - titleLen;
-  strLeft = char.repeat(nLeft);
-  strMiddle = ' '.repeat(padding) + title + ' '.repeat(padding);
-  strRight = char.repeat(nRight);
-  return strLeft + strMiddle + strRight;
-};
-
-// ---------------------------------------------------------------------------
-//   rtrunc - strip nChars chars from right of a string
-export var rtrunc = function(str, nChars) {
-  return str.substring(0, str.length - nChars);
-};
-
-// ---------------------------------------------------------------------------
-//   ltrunc - strip nChars chars from left of a string
-export var ltrunc = function(str, nChars) {
-  return str.substring(nChars);
-};
-
-// ---------------------------------------------------------------------------
-export var removeCR = function(str) {
-  return str.replace(/\r/g, '');
-};
-
-// ---------------------------------------------------------------------------
-export var CWS = function(str) {
-  assert(isString(str), "CWS(): parameter not a string");
-  return str.trim().replace(/\s+/sg, ' ');
-};
-
-// ---------------------------------------------------------------------------
-export var extractMatches = function(line, regexp, convertFunc = undef) {
-  var lConverted, lStrings, str;
-  lStrings = [...line.matchAll(regexp)];
-  lStrings = (function() {
-    var i, len, results;
-    results = [];
-    for (i = 0, len = lStrings.length; i < len; i++) {
-      str = lStrings[i];
-      results.push(str[0]);
-    }
-    return results;
-  })();
-  if (defined(convertFunc)) {
-    lConverted = (function() {
-      var i, len, results;
-      results = [];
-      for (i = 0, len = lStrings.length; i < len; i++) {
-        str = lStrings[i];
-        results.push(convertFunc(str));
-      }
-      return results;
-    })();
-    return lConverted;
-  } else {
-    return lStrings;
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var envVarsWithPrefix = function(prefix, hOptions = {}) {
-  var h, i, key, len, plen, ref;
-  // --- valid options:
-  //        stripPrefix
-  assert(prefix, "envVarsWithPrefix: empty prefix!");
-  plen = prefix.length;
-  h = {};
-  ref = Object.keys(process.env);
-  for (i = 0, len = ref.length; i < len; i++) {
-    key = ref[i];
-    if (key.indexOf(prefix) === 0) {
-      if (hOptions.stripPrefix) {
-        h[key.substr(plen)] = process.env[key];
-      } else {
-        h[key] = process.env[key];
-      }
-    }
-  }
-  return h;
-};
-
-// ---------------------------------------------------------------------------
-export var getTimeStr = function(date = undef) {
-  if (date === undef) {
-    date = new Date();
-  }
-  return date.toLocaleTimeString('en-US');
-};
-
-// ---------------------------------------------------------------------------
-export var getDateStr = function(date = undef) {
-  if (date === undef) {
-    date = new Date();
-  }
-  return date.toLocaleDateString('en-US');
-};
-
-// ---------------------------------------------------------------------------
-export var strcat = function(...lItems) {
-  var i, item, len, str;
-  str = '';
-  for (i = 0, len = lItems.length; i < len; i++) {
-    item = lItems[i];
-    str += item.toString();
-  }
-  return str;
-};
-
-// ---------------------------------------------------------------------------
-export var replaceVars = function(line, hVars = {}, rx = /__(env\.)?([A-Za-z_]\w*)__/g) {
-  var replacerFunc;
-  assert(isHash(hVars), "replaceVars() hVars is not a hash");
-  replacerFunc = (match, prefix, name) => {
-    var value;
-    if (prefix) {
-      return process.env[name];
-    } else {
-      value = hVars[name];
-      if (defined(value)) {
-        if (isString(value)) {
-          return value;
-        } else {
-          return JSON.stringify(value);
-        }
-      } else {
-        return `__${name}__`;
-      }
-    }
-  };
-  return line.replace(rx, replacerFunc);
-};
-
-// ---------------------------------------------------------------------------
-export var className = function(aClass) {
-  var lMatches;
-  if (lMatches = aClass.toString().match(/class\s+(\w+)/)) {
-    return lMatches[1];
-  } else {
-    return croak("className(): Bad input class");
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var timestamp = function() {
-  return new Date().toLocaleTimeString("en-US");
-};