@jdeighan/coffee-utils 14.0.6 → 14.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "14.0.6",
+	"version": "14.0.7",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {

package/src/DataStores.coffee

@@ -218,7 +218,7 @@ export class ToDoDataStore extends BaseDataStore
 #         UTILITIES
 # ---------------------------------------------------------------------------
 
-export brewTamlStr = (code, stub) ->
+export brewTamlStr = (code, stub) =>
 
 	return """
 			import {TAMLDataStore} from '@jdeighan/starbucks/stores';
@@ -228,7 +228,7 @@ export brewTamlStr = (code, stub) ->
 
 # ---------------------------------------------------------------------------
 
-export brewTamlFile = (srcPath, destPath=undef, hOptions={}) ->
+export brewTamlFile = (srcPath, destPath=undef, hOptions={}) =>
 	# --- taml => js
 	#     Valid Options:
 	#        force

package/src/DataStores.js

@@ -289,14 +289,14 @@ export var ToDoDataStore = class ToDoDataStore extends BaseDataStore {
 // ---------------------------------------------------------------------------
 //         UTILITIES
 // ---------------------------------------------------------------------------
-export var brewTamlStr = function(code, stub) {
+export var brewTamlStr = (code, stub) => {
   return `import {TAMLDataStore} from '@jdeighan/starbucks/stores';
 
 export let ${stub} = new TAMLDataStore(\`${code}\`);`;
 };
 
 // ---------------------------------------------------------------------------
-export var brewTamlFile = function(srcPath, destPath = undef, hOptions = {}) {
+export var brewTamlFile = (srcPath, destPath = undef, hOptions = {}) => {
   var hInfo, jsCode, stub, tamlCode;
   if (destPath == null) {
     destPath = withExt(srcPath, '.js', {

package/src/SectionMap.coffee

@@ -16,13 +16,13 @@ import {Section} from '@jdeighan/coffee-utils/section'
 
 # ---------------------------------------------------------------------------
 
-isSectionName = (name) ->
+isSectionName = (name) =>
 
 	return isString(name) && name.match(/^[a-z][a-z0-9_]*/)
 
 # ---------------------------------------------------------------------------
 
-isSetName = (name) ->
+isSetName = (name) =>
 
 	return isString(name) && name.match(/^[A-Z][a-z0-9_]*/)
 

package/src/SectionMap.js

@@ -50,12 +50,12 @@ import {
 } from '@jdeighan/coffee-utils/section';
 
 // ---------------------------------------------------------------------------
-isSectionName = function(name) {
+isSectionName = (name) => {
   return isString(name) && name.match(/^[a-z][a-z0-9_]*/);
 };
 
 // ---------------------------------------------------------------------------
-isSetName = function(name) {
+isSetName = (name) => {
   return isString(name) && name.match(/^[A-Z][a-z0-9_]*/);
 };
 

package/src/block.coffee

@@ -11,7 +11,7 @@ import {
 
 # ---------------------------------------------------------------------------
 
-export splitBlock = (block) ->
+export splitBlock = (block) =>
 
 	assert isString(block), "not a string"
 	pos = block.indexOf('\n')
@@ -23,7 +23,7 @@ export splitBlock = (block) ->
 
 # ---------------------------------------------------------------------------
 
-export firstLine = (block) ->
+export firstLine = (block) =>
 
 	assert isString(block), "not a string"
 	pos = block.indexOf('\n')
@@ -34,7 +34,7 @@ export firstLine = (block) ->
 
 # ---------------------------------------------------------------------------
 
-export remainingLines = (block) ->
+export remainingLines = (block) =>
 
 	assert isString(block), "not a string"
 	pos = block.indexOf('\n')
@@ -47,7 +47,7 @@ export remainingLines = (block) ->
 #   normalizeBlock - remove blank lines, trim each line
 #                  - collapse internal whitespace to ' '
 
-export normalizeBlock = (content) ->
+export normalizeBlock = (content) =>
 
 	if typeof content != 'string'
 		throw new Error("normalizeBlock(): not a string")
@@ -60,7 +60,7 @@ export normalizeBlock = (content) ->
 # ---------------------------------------------------------------------------
 # truncateBlock - limit block to a certain number of lines
 
-export truncateBlock = (str, numLines) ->
+export truncateBlock = (str, numLines) =>
 
 	lLines = toArray str
 	lLines.length = numLines
@@ -68,7 +68,7 @@ export truncateBlock = (str, numLines) ->
 
 # ---------------------------------------------------------------------------
 
-export joinBlocks = (lBlocks...) ->
+export joinBlocks = (lBlocks...) =>
 
 	lNonEmptyBlocks = []
 	for block in lBlocks.flat(999)

package/src/block.js

@@ -26,7 +26,7 @@ import {
 } from '@jdeighan/base-utils';
 
 // ---------------------------------------------------------------------------
-export var splitBlock = function(block) {
+export var splitBlock = (block) => {
   var pos;
   assert(isString(block), "not a string");
   pos = block.indexOf('\n');
@@ -38,7 +38,7 @@ export var splitBlock = function(block) {
 };
 
 // ---------------------------------------------------------------------------
-export var firstLine = function(block) {
+export var firstLine = (block) => {
   var pos;
   assert(isString(block), "not a string");
   pos = block.indexOf('\n');
@@ -50,7 +50,7 @@ export var firstLine = function(block) {
 };
 
 // ---------------------------------------------------------------------------
-export var remainingLines = function(block) {
+export var remainingLines = (block) => {
   var pos;
   assert(isString(block), "not a string");
   pos = block.indexOf('\n');
@@ -64,7 +64,7 @@ export var remainingLines = function(block) {
 // ---------------------------------------------------------------------------
 //   normalizeBlock - remove blank lines, trim each line
 //                  - collapse internal whitespace to ' '
-export var normalizeBlock = function(content) {
+export var normalizeBlock = (content) => {
   var lLines, line;
   if (typeof content !== 'string') {
     throw new Error("normalizeBlock(): not a string");
@@ -88,7 +88,7 @@ export var normalizeBlock = function(content) {
 
 // ---------------------------------------------------------------------------
 // truncateBlock - limit block to a certain number of lines
-export var truncateBlock = function(str, numLines) {
+export var truncateBlock = (str, numLines) => {
   var lLines;
   lLines = toArray(str);
   lLines.length = numLines;
@@ -96,7 +96,7 @@ export var truncateBlock = function(str, numLines) {
 };
 
 // ---------------------------------------------------------------------------
-export var joinBlocks = function(...lBlocks) {
+export var joinBlocks = (...lBlocks) => {
   var block, i, lNonEmptyBlocks, len, ref;
   lNonEmptyBlocks = [];
   ref = lBlocks.flat(999);

package/src/browser.coffee

@@ -7,7 +7,7 @@ audio = undef   # audio context - create only when needed, then keep
 # ---------------------------------------------------------------------------
 #   beep - play a sound
 
-export beep = (volume=100, freq=520, duration=200) ->
+export beep = (volume=100, freq=520, duration=200) =>
 
 	if audio == undef
 		audio = new AudioContext()
@@ -24,7 +24,7 @@ export beep = (volume=100, freq=520, duration=200) ->
 
 # ---------------------------------------------------------------------------
 
-export localStore = (key, value=undef) ->
+export localStore = (key, value=undef) =>
 	# --- if value is undef, returns the current value
 
 	if typeof localStorage == 'undefined'

package/src/browser.js

@@ -11,7 +11,7 @@ audio = undef; // audio context - create only when needed, then keep
 
 // ---------------------------------------------------------------------------
 //   beep - play a sound
-export var beep = function(volume = 100, freq = 520, duration = 200) {
+export var beep = (volume = 100, freq = 520, duration = 200) => {
   var u, v;
   if (audio === undef) {
     audio = new AudioContext();
@@ -28,7 +28,7 @@ export var beep = function(volume = 100, freq = 520, duration = 200) {
 };
 
 // ---------------------------------------------------------------------------
-export var localStore = function(key, value = undef) {
+export var localStore = (key, value = undef) => {
   // --- if value is undef, returns the current value
   if (typeof localStorage === 'undefined') {
     return;

package/src/fs.coffee

@@ -19,7 +19,7 @@ import {fromTAML} from '@jdeighan/base-utils/taml'
 #    mydir() - pass argument import.meta.url and it will return
 #              the directory your file is in
 
-export mydir = (url) ->
+export mydir = (url) =>
 
 	path = urllib.fileURLToPath(url)
 	dir = pathlib.dirname(path)
@@ -28,7 +28,7 @@ export mydir = (url) ->
 
 # ---------------------------------------------------------------------------
 
-export projRoot = (url) ->
+export projRoot = (url) =>
 
 	dir = mydir(url)
 	rootDir = pathTo('package.json', dir, 'direction=up directory')
@@ -39,7 +39,7 @@ export projRoot = (url) ->
 #    myfile() - pass argument import.meta.url and it will return
 #               the name of your file
 
-export myfile = (url) ->
+export myfile = (url) =>
 
 	path = urllib.fileURLToPath(url)
 	filename = pathlib.parse(path).base
@@ -49,20 +49,20 @@ export myfile = (url) ->
 #    myfullpath() - pass argument import.meta.url and it will return
 #                   the full path to your file
 
-export myfullpath = (url) ->
+export myfullpath = (url) =>
 
 	path = urllib.fileURLToPath(url)
 	return mkpath(path)
 
 # ---------------------------------------------------------------------------
 
-export getStats = (fullpath) ->
+export getStats = (fullpath) =>
 
 	return fs.lstatSync(fullpath)
 
 # ---------------------------------------------------------------------------
 
-export isFile = (fullpath) ->
+export isFile = (fullpath) =>
 
 	try
 		return getStats(fullpath).isFile()
@@ -71,7 +71,7 @@ export isFile = (fullpath) ->
 
 # ---------------------------------------------------------------------------
 
-export isDir = (fullpath) ->
+export isDir = (fullpath) =>
 
 	try
 		return getStats(fullpath).isDirectory()
@@ -80,14 +80,14 @@ export isDir = (fullpath) ->
 
 # ---------------------------------------------------------------------------
 
-export isSimpleFileName = (path) ->
+export isSimpleFileName = (path) =>
 
 	h = pathlib.parse(path)
 	return ! h.root && ! h.dir && h.base
 
 # ---------------------------------------------------------------------------
 
-export fileStub = (path) ->
+export fileStub = (path) =>
 
 	assert isString(path), "fileExt(): path not a string"
 	if lMatches = path.match(/^(.*)\.[A-Za-z0-9_]+$/)
@@ -97,7 +97,7 @@ export fileStub = (path) ->
 
 # ---------------------------------------------------------------------------
 
-export fileExt = (path) ->
+export fileExt = (path) =>
 
 	assert isString(path), "fileExt(): path not a string"
 	if lMatches = path.match(/\.[A-Za-z0-9_]+$/)
@@ -107,7 +107,7 @@ export fileExt = (path) ->
 
 # ---------------------------------------------------------------------------
 
-export mkpath = (lParts...) ->
+export mkpath = (lParts...) =>
 
 	# --- Ignore empty parts
 	lNewParts = []
@@ -124,13 +124,13 @@ export mkpath = (lParts...) ->
 
 # ---------------------------------------------------------------------------
 
-export getFullPath = (filepath) ->
+export getFullPath = (filepath) =>
 
 	return mkpath(pathlib.resolve(filepath))
 
 # ---------------------------------------------------------------------------
 
-export forEachLine = (filepath, func) ->
+export forEachLine = (filepath, func) =>
 
 	reader = new NReadLines(filepath)
 	nLines = 0
@@ -146,7 +146,7 @@ export forEachLine = (filepath, func) ->
 
 # ---------------------------------------------------------------------------
 
-export forEachBlock = (filepath, func, regexp = /^-{16,}$/) ->
+export forEachBlock = (filepath, func, regexp = /^-{16,}$/) =>
 
 	lLines = []
 	firstLineNum = 1
@@ -175,7 +175,7 @@ export forEachBlock = (filepath, func, regexp = /^-{16,}$/) ->
 
 export forEachSetOfBlocks = (filepath, func,
 		block_regexp = /^-{16,}$/,
-		set_regexp   = /^={16,}$/) ->
+		set_regexp   = /^={16,}$/) =>
 
 	lBlocks = []
 	lLines = []
@@ -210,7 +210,7 @@ export forEachSetOfBlocks = (filepath, func,
 # ---------------------------------------------------------------------------
 #   slurp - read an entire file into a string
 
-export slurp = (filepath, maxLines=undef) ->
+export slurp = (filepath, maxLines=undef) =>
 
 	if defined(maxLines)
 		lLines = []
@@ -226,7 +226,7 @@ export slurp = (filepath, maxLines=undef) ->
 # ---------------------------------------------------------------------------
 #   barf - write a string to a file
 
-export barf = (filepath, contents) ->
+export barf = (filepath, contents) =>
 
 	if isEmpty(contents)
 		return
@@ -241,7 +241,7 @@ export barf = (filepath, contents) ->
 # ---------------------------------------------------------------------------
 #   withExt - change file extention in a file name
 
-export withExt = (path, newExt, hOptions={}) ->
+export withExt = (path, newExt, hOptions={}) =>
 	# --- Valid options:
 	#        removeLeadingUnderScore - boolean
 
@@ -257,7 +257,7 @@ export withExt = (path, newExt, hOptions={}) ->
 # ---------------------------------------------------------------------------
 #   removeFileWithExt - remove file with different ext
 
-export removeFileWithExt = (path, newExt, hOptions={}) ->
+export removeFileWithExt = (path, newExt, hOptions={}) =>
 	# --- Valid options:
 	#        doLog
 	#        removeLeadingUnderScore
@@ -276,7 +276,7 @@ export removeFileWithExt = (path, newExt, hOptions={}) ->
 # ---------------------------------------------------------------------------
 #   withUnderScore - add '_' to file name
 
-export withUnderScore = (path) ->
+export withUnderScore = (path) =>
 
 	{dir, base} = pathlib.parse(path)
 	return mkpath(dir, "_#{base}")
@@ -290,7 +290,7 @@ isSystemDir = (dir) ->
 # ---------------------------------------------------------------------------
 #    Get all subdirectories of a directory
 
-export getSubDirs = (dir) ->
+export getSubDirs = (dir) =>
 
 	return fs.readdirSync(dir, {withFileTypes: true}) \
 		.filter((d) -> d.isDirectory() && !isSystemDir(d.name)) \
@@ -300,7 +300,7 @@ export getSubDirs = (dir) ->
 # ---------------------------------------------------------------------------
 #    Get path to parent directory of a directory
 
-export getParentDir = (dir) ->
+export getParentDir = (dir) =>
 
 	hParts = pathlib.parse(dir)
 	if (hParts.dir == hParts.root)
@@ -309,7 +309,7 @@ export getParentDir = (dir) ->
 
 # ---------------------------------------------------------------------------
 
-export forEachFile = (dir, cb, filt=undef, level=0) ->
+export forEachFile = (dir, cb, filt=undef, level=0) =>
 	# --- filt can be a regular expression or a function that gets:
 	#        (filename, dir, level)
 	#     callback will get parms (filename, dir, level)
@@ -336,7 +336,7 @@ export forEachFile = (dir, cb, filt=undef, level=0) ->
 
 # ---------------------------------------------------------------------------
 
-export pathTo = (fname, searchDir, options=undef) ->
+export pathTo = (fname, searchDir, options=undef) =>
 
 	{direction, relative, directory} = getOptions(options, {
 		direction: 'down'
@@ -388,7 +388,7 @@ export pathTo = (fname, searchDir, options=undef) ->
 
 # ---------------------------------------------------------------------------
 
-export allPathsTo = (fname, searchDir) ->
+export allPathsTo = (fname, searchDir) =>
 	# --- Only searches upward
 
 	if ! searchDir
@@ -406,7 +406,7 @@ export allPathsTo = (fname, searchDir) ->
 
 # ---------------------------------------------------------------------------
 
-export newerDestFileExists = (srcPath, destPath) ->
+export newerDestFileExists = (srcPath, destPath) =>
 
 	if ! fs.existsSync(destPath)
 		return false
@@ -419,7 +419,7 @@ export newerDestFileExists = (srcPath, destPath) ->
 
 # ---------------------------------------------------------------------------
 
-export shortenPath = (path) ->
+export shortenPath = (path) =>
 	# --- Replace user's home dir with '~'
 
 	str = mkpath(path)
@@ -433,7 +433,7 @@ export shortenPath = (path) ->
 
 # ---------------------------------------------------------------------------
 
-export parseSource = (source) ->
+export parseSource = (source) =>
 	# --- returns {
 	#        dir
 	#        filename
@@ -487,7 +487,7 @@ export parseSource = (source) ->
 # ---------------------------------------------------------------------------
 #   slurpTAML - read TAML from a file
 
-export slurpTAML = (filepath) ->
+export slurpTAML = (filepath) =>
 
 	contents = slurp(filepath)
 	return fromTAML(contents)

package/src/fs.js

@@ -52,7 +52,7 @@ import {
 // ---------------------------------------------------------------------------
 //    mydir() - pass argument import.meta.url and it will return
 //              the directory your file is in
-export var mydir = function(url) {
+export var mydir = (url) => {
   var dir, final, path;
   path = urllib.fileURLToPath(url);
   dir = pathlib.dirname(path);
@@ -61,7 +61,7 @@ export var mydir = function(url) {
 };
 
 // ---------------------------------------------------------------------------
-export var projRoot = function(url) {
+export var projRoot = (url) => {
   var dir, rootDir;
   dir = mydir(url);
   rootDir = pathTo('package.json', dir, 'direction=up directory');
@@ -72,7 +72,7 @@ export var projRoot = function(url) {
 // ---------------------------------------------------------------------------
 //    myfile() - pass argument import.meta.url and it will return
 //               the name of your file
-export var myfile = function(url) {
+export var myfile = (url) => {
   var filename, path;
   path = urllib.fileURLToPath(url);
   filename = pathlib.parse(path).base;
@@ -82,19 +82,19 @@ export var myfile = function(url) {
 // ---------------------------------------------------------------------------
 //    myfullpath() - pass argument import.meta.url and it will return
 //                   the full path to your file
-export var myfullpath = function(url) {
+export var myfullpath = (url) => {
   var path;
   path = urllib.fileURLToPath(url);
   return mkpath(path);
 };
 
 // ---------------------------------------------------------------------------
-export var getStats = function(fullpath) {
+export var getStats = (fullpath) => {
   return fs.lstatSync(fullpath);
 };
 
 // ---------------------------------------------------------------------------
-export var isFile = function(fullpath) {
+export var isFile = (fullpath) => {
   try {
     return getStats(fullpath).isFile();
   } catch (error) {
@@ -103,7 +103,7 @@ export var isFile = function(fullpath) {
 };
 
 // ---------------------------------------------------------------------------
-export var isDir = function(fullpath) {
+export var isDir = (fullpath) => {
   try {
     return getStats(fullpath).isDirectory();
   } catch (error) {
@@ -112,14 +112,14 @@ export var isDir = function(fullpath) {
 };
 
 // ---------------------------------------------------------------------------
-export var isSimpleFileName = function(path) {
+export var isSimpleFileName = (path) => {
   var h;
   h = pathlib.parse(path);
   return !h.root && !h.dir && h.base;
 };
 
 // ---------------------------------------------------------------------------
-export var fileStub = function(path) {
+export var fileStub = (path) => {
   var lMatches;
   assert(isString(path), "fileExt(): path not a string");
   if (lMatches = path.match(/^(.*)\.[A-Za-z0-9_]+$/)) {
@@ -130,7 +130,7 @@ export var fileStub = function(path) {
 };
 
 // ---------------------------------------------------------------------------
-export var fileExt = function(path) {
+export var fileExt = (path) => {
   var lMatches;
   assert(isString(path), "fileExt(): path not a string");
   if (lMatches = path.match(/\.[A-Za-z0-9_]+$/)) {
@@ -141,7 +141,7 @@ export var fileExt = function(path) {
 };
 
 // ---------------------------------------------------------------------------
-export var mkpath = function(...lParts) {
+export var mkpath = (...lParts) => {
   var _, drive, i, lMatches, lNewParts, len, newPath, part, rest;
   // --- Ignore empty parts
   lNewParts = [];
@@ -161,12 +161,12 @@ export var mkpath = function(...lParts) {
 };
 
 // ---------------------------------------------------------------------------
-export var getFullPath = function(filepath) {
+export var getFullPath = (filepath) => {
   return mkpath(pathlib.resolve(filepath));
 };
 
 // ---------------------------------------------------------------------------
-export var forEachLine = function(filepath, func) {
+export var forEachLine = (filepath, func) => {
   var buffer, line, nLines, reader;
   reader = new NReadLines(filepath);
   nLines = 0;
@@ -182,7 +182,7 @@ export var forEachLine = function(filepath, func) {
 };
 
 // ---------------------------------------------------------------------------
-export var forEachBlock = function(filepath, func, regexp = /^-{16,}$/) {
+export var forEachBlock = (filepath, func, regexp = /^-{16,}$/) => {
   var callback, earlyExit, firstLineNum, lLines;
   lLines = [];
   firstLineNum = 1;
@@ -211,7 +211,7 @@ export var forEachBlock = function(filepath, func, regexp = /^-{16,}$/) {
 };
 
 // ---------------------------------------------------------------------------
-export var forEachSetOfBlocks = function(filepath, func, block_regexp = /^-{16,}$/, set_regexp = /^={16,}$/) {
+export var forEachSetOfBlocks = (filepath, func, block_regexp = /^-{16,}$/, set_regexp = /^={16,}$/) => {
   var callback, earlyExit, firstLineNum, lBlocks, lLines;
   lBlocks = [];
   lLines = [];
@@ -248,7 +248,7 @@ export var forEachSetOfBlocks = function(filepath, func, block_regexp = /^-{16,}
 
 // ---------------------------------------------------------------------------
 //   slurp - read an entire file into a string
-export var slurp = function(filepath, maxLines = undef) {
+export var slurp = (filepath, maxLines = undef) => {
   var contents, lLines;
   if (defined(maxLines)) {
     lLines = [];
@@ -266,7 +266,7 @@ export var slurp = function(filepath, maxLines = undef) {
 
 // ---------------------------------------------------------------------------
 //   barf - write a string to a file
-export var barf = function(filepath, contents) {
+export var barf = (filepath, contents) => {
   if (isEmpty(contents)) {
     return;
   }
@@ -283,7 +283,7 @@ export var barf = function(filepath, contents) {
 
 // ---------------------------------------------------------------------------
 //   withExt - change file extention in a file name
-export var withExt = function(path, newExt, hOptions = {}) {
+export var withExt = (path, newExt, hOptions = {}) => {
   var dir, ext, name;
   // --- Valid options:
   //        removeLeadingUnderScore - boolean
@@ -300,7 +300,7 @@ export var withExt = function(path, newExt, hOptions = {}) {
 
 // ---------------------------------------------------------------------------
 //   removeFileWithExt - remove file with different ext
-export var removeFileWithExt = function(path, newExt, hOptions = {}) {
+export var removeFileWithExt = (path, newExt, hOptions = {}) => {
   var err, fullpath, success;
   // --- Valid options:
   //        doLog
@@ -322,7 +322,7 @@ export var removeFileWithExt = function(path, newExt, hOptions = {}) {
 
 // ---------------------------------------------------------------------------
 //   withUnderScore - add '_' to file name
-export var withUnderScore = function(path) {
+export var withUnderScore = (path) => {
   var base, dir;
   ({dir, base} = pathlib.parse(path));
   return mkpath(dir, `_${base}`);
@@ -335,7 +335,7 @@ isSystemDir = function(dir) {
 
 // ---------------------------------------------------------------------------
 //    Get all subdirectories of a directory
-export var getSubDirs = function(dir) {
+export var getSubDirs = (dir) => {
   return fs.readdirSync(dir, {
     withFileTypes: true
   }).filter(function(d) {
@@ -347,7 +347,7 @@ export var getSubDirs = function(dir) {
 
 // ---------------------------------------------------------------------------
 //    Get path to parent directory of a directory
-export var getParentDir = function(dir) {
+export var getParentDir = (dir) => {
   var hParts;
   hParts = pathlib.parse(dir);
   if (hParts.dir === hParts.root) {
@@ -357,7 +357,7 @@ export var getParentDir = function(dir) {
 };
 
 // ---------------------------------------------------------------------------
-export var forEachFile = function(dir, cb, filt = undef, level = 0) {
+export var forEachFile = (dir, cb, filt = undef, level = 0) => {
   var ent, i, j, lSubDirectories, len, len1, ref, ref1, subdir;
   // --- filt can be a regular expression or a function that gets:
   //        (filename, dir, level)
@@ -396,7 +396,7 @@ export var forEachFile = function(dir, cb, filt = undef, level = 0) {
 };
 
 // ---------------------------------------------------------------------------
-export var pathTo = function(fname, searchDir, options = undef) {
+export var pathTo = (fname, searchDir, options = undef) => {
   var dirPath, direction, directory, filepath, fpath, i, len, nLevels, ref, relative, subdir;
   ({direction, relative, directory} = getOptions(options, {
     direction: 'down',
@@ -458,7 +458,7 @@ export var pathTo = function(fname, searchDir, options = undef) {
 };
 
 // ---------------------------------------------------------------------------
-export var allPathsTo = function(fname, searchDir) {
+export var allPathsTo = (fname, searchDir) => {
   var h, lPaths, path;
   if (!searchDir) {
     searchDir = process.cwd();
@@ -481,7 +481,7 @@ export var allPathsTo = function(fname, searchDir) {
 };
 
 // ---------------------------------------------------------------------------
-export var newerDestFileExists = function(srcPath, destPath) {
+export var newerDestFileExists = (srcPath, destPath) => {
   var destModTime, srcModTime;
   if (!fs.existsSync(destPath)) {
     return false;
@@ -496,7 +496,7 @@ export var newerDestFileExists = function(srcPath, destPath) {
 };
 
 // ---------------------------------------------------------------------------
-export var shortenPath = function(path) {
+export var shortenPath = (path) => {
   var _, lMatches, str, tail;
   // --- Replace user's home dir with '~'
   str = mkpath(path);
@@ -509,7 +509,7 @@ export var shortenPath = function(path) {
 };
 
 // ---------------------------------------------------------------------------
-export var parseSource = function(source) {
+export var parseSource = (source) => {
   var dir, hInfo, hSourceInfo, lMatches;
   // --- returns {
   //        dir
@@ -562,7 +562,7 @@ export var parseSource = function(source) {
 
 // ---------------------------------------------------------------------------
 //   slurpTAML - read TAML from a file
-export var slurpTAML = function(filepath) {
+export var slurpTAML = (filepath) => {
   var contents;
   contents = slurp(filepath);
   return fromTAML(contents);

package/src/html.coffee

@@ -13,7 +13,7 @@ for tagName in words('area base br col command embed hr img input' \
 
 # ---------------------------------------------------------------------------
 
-export parsetag = (line) ->
+export parsetag = (line) =>
 
 	if lMatches = line.match(///^
 			(?:
@@ -159,7 +159,7 @@ export parsetag = (line) ->
 # ---------------------------------------------------------------------------
 # --- export only for unit testing
 
-export attrStr = (hAttr) ->
+export attrStr = (hAttr) =>
 
 	if ! hAttr
 		return ''
@@ -179,7 +179,7 @@ export attrStr = (hAttr) ->
 
 # ---------------------------------------------------------------------------
 
-export tag2str = (hToken, type='begin') ->
+export tag2str = (hToken, type='begin') =>
 
 	{tagName, hAttr} = hToken
 	if (type == 'begin')
@@ -199,7 +199,7 @@ export tag2str = (hToken, type='begin') ->
 # ---------------------------------------------------------------------------
 #    elem - indent text, surround with HTML tags
 
-export elem = (tagName, hAttr=undef, text=undef, oneIndent="\t") ->
+export elem = (tagName, hAttr=undef, text=undef, oneIndent="\t") =>
 
 	if isEmpty(text)
 		hToken = {tagName, hAttr}

package/src/html.js

@@ -29,7 +29,7 @@ for (i = 0, len = ref.length; i < len; i++) {
 }
 
 // ---------------------------------------------------------------------------
-export var parsetag = function(line) {
+export var parsetag = (line) => {
   var _, all, attrName, br_val, className, dq_val, hAttr, hToken, ident, j, lClasses, lMatches, len1, modifiers, prefix, quote, ref1, rest, sq_val, subtype, uq_val, value, varName;
   if (lMatches = line.match(/^(?:([A-Za-z][A-Za-z0-9_]*)\s*=\s*)?([A-Za-z][A-Za-z0-9_]*)(?:\:([a-z]+))?(\S*)\s*(.*)$/)) { // variable name
     // variable is optional
@@ -155,7 +155,7 @@ export var parsetag = function(line) {
 
 // ---------------------------------------------------------------------------
 // --- export only for unit testing
-export var attrStr = function(hAttr) {
+export var attrStr = (hAttr) => {
   var attrName, bquote, equote, j, len1, quote, ref1, shorthand, str, value;
   if (!hAttr) {
     return '';
@@ -181,7 +181,7 @@ export var attrStr = function(hAttr) {
 };
 
 // ---------------------------------------------------------------------------
-export var tag2str = function(hToken, type = 'begin') {
+export var tag2str = (hToken, type = 'begin') => {
   var hAttr, str;
   ({tagName, hAttr} = hToken);
   if (type === 'begin') {
@@ -204,7 +204,7 @@ export var tag2str = function(hToken, type = 'begin') {
 
 // ---------------------------------------------------------------------------
 //    elem - indent text, surround with HTML tags
-export var elem = function(tagName, hAttr = undef, text = undef, oneIndent = "\t") {
+export var elem = (tagName, hAttr = undef, text = undef, oneIndent = "\t") => {
   var hToken;
   if (isEmpty(text)) {
     hToken = {tagName, hAttr};

package/src/indent.coffee

@@ -8,7 +8,7 @@ import {
 
 # ---------------------------------------------------------------------------
 
-export getOneIndent = (str) ->
+export getOneIndent = (str) =>
 
 	if (lMatches = str.match(/^\t+(?:\S|$)/))
 		return "\t"
@@ -19,7 +19,7 @@ export getOneIndent = (str) ->
 
 # ---------------------------------------------------------------------------
 
-export splitPrefix = (line) ->
+export splitPrefix = (line) =>
 
 	assert isString(line), "non-string #{OL(line)}"
 	line = rtrim(line)
@@ -29,7 +29,7 @@ export splitPrefix = (line) ->
 # ---------------------------------------------------------------------------
 #   splitLine - separate a line into [level, line]
 
-export splitLine = (line, oneIndent=undef) ->
+export splitLine = (line, oneIndent=undef) =>
 
 	[prefix, str] = splitPrefix(line)
 	return [indentLevel(prefix, oneIndent), str]
@@ -38,7 +38,7 @@ export splitLine = (line, oneIndent=undef) ->
 #   indentation - return appropriate indentation string for given level
 #   export only to allow unit testing
 
-export indentation = (level, oneIndent="\t") ->
+export indentation = (level, oneIndent="\t") =>
 
 	assert (level >= 0), "indentation(): negative level"
 	return oneIndent.repeat(level)
@@ -47,47 +47,53 @@ export indentation = (level, oneIndent="\t") ->
 #   indentLevel - determine indent level of a string
 #                 it's OK if the string is ONLY indentation
 
-export indentLevel = (line, oneIndent=undef) ->
+export indentLevel = (line, oneIndent=undef) =>
 
 	assert isString(line), "not a string"
 
 	# --- This will always match, and it's greedy
-	if lMatches = line.match(/^(\s*)/)
-		prefix = lMatches[1]
+	if lMatches = line.match(/^\s*/)
+		prefix = lMatches[0]
 		prefixLen = prefix.length
 
 	if (prefixLen == 0)
 		return 0
 
 	if defined(oneIndent)
+		# --- prefix must be some multiple of oneIndent
 		len = oneIndent.length
-	else
-		oneIndent = "\t"
-		len = 1
-
-	if (prefixLen % len != 0)
-		croak "prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
+		assert (prefixLen % len == 0),
+			"prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
 
-	level = prefixLen / len
-	if (prefix != oneIndent.repeat(level))
-		croak "prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
+		level = prefixLen / len
+	else
+		ch = prefix.substring(0, 1)
+		if (ch == "\t")
+			oneIndent = "\t"
+			level = prefixLen
+		else if (ch == ' ')
+			oneIndent = ' '.repeat(prefixLen)
+			level = 1
+		else
+			croak "Bad Indentation in #{OL(line)}"
 
+	assert (prefix == oneIndent.repeat(level)),
+		"prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
 	return level
 
 # ---------------------------------------------------------------------------
 #   isUndented - true iff indentLevel(line) == 0
 
-export isUndented = (line) ->
+export isUndented = (line) =>
 
 	assert isString(line), "non-string #{OL(line)}"
-	lMatches = line.match(/^\s*/)
-	return (lMatches[0].length == 0)
+	return notdefined(line.match(/^\s/))
 
 # ---------------------------------------------------------------------------
 #   indented - add indentation to each string in a block or array
 #            - returns the same type as input, i.e. array or string
 
-export indented = (input, level=1, oneIndent="\t") ->
+export indented = (input, level=1, oneIndent="\t") =>
 
 	# --- level can be a string, in which case it is
 	#     pre-pended to each line of input
@@ -125,7 +131,7 @@ export indented = (input, level=1, oneIndent="\t") ->
 #              indentation is removed
 #            - returns same type as text, i.e. either string or array
 
-export undented = (input, level=undef, oneIndent="\t") ->
+export undented = (input, level=undef, oneIndent="\t") =>
 
 	if defined(level) && (level==0)
 		return input
@@ -163,7 +169,7 @@ export undented = (input, level=undef, oneIndent="\t") ->
 # ---------------------------------------------------------------------------
 #    enclose - indent text, surround with pre and post
 
-export enclose = (text, pre, post, oneIndent="\t") ->
+export enclose = (text, pre, post, oneIndent="\t") =>
 
 	return toBlock([
 		pre

package/src/indent.js

@@ -20,7 +20,7 @@ import {
 } from '@jdeighan/base-utils';
 
 // ---------------------------------------------------------------------------
-export var getOneIndent = function(str) {
+export var getOneIndent = (str) => {
   var lMatches;
   if ((lMatches = str.match(/^\t+(?:\S|$)/))) {
     return "\t";
@@ -32,7 +32,7 @@ export var getOneIndent = function(str) {
 };
 
 // ---------------------------------------------------------------------------
-export var splitPrefix = function(line) {
+export var splitPrefix = (line) => {
   var lMatches;
   assert(isString(line), `non-string ${OL(line)}`);
   line = rtrim(line);
@@ -42,7 +42,7 @@ export var splitPrefix = function(line) {
 
 // ---------------------------------------------------------------------------
 //   splitLine - separate a line into [level, line]
-export var splitLine = function(line, oneIndent = undef) {
+export var splitLine = (line, oneIndent = undef) => {
   var prefix, str;
   [prefix, str] = splitPrefix(line);
   return [indentLevel(prefix, oneIndent), str];
@@ -51,7 +51,7 @@ export var splitLine = function(line, oneIndent = undef) {
 // ---------------------------------------------------------------------------
 //   indentation - return appropriate indentation string for given level
 //   export only to allow unit testing
-export var indentation = function(level, oneIndent = "\t") {
+export var indentation = (level, oneIndent = "\t") => {
   assert(level >= 0, "indentation(): negative level");
   return oneIndent.repeat(level);
 };
@@ -59,46 +59,49 @@ export var indentation = function(level, oneIndent = "\t") {
 // ---------------------------------------------------------------------------
 //   indentLevel - determine indent level of a string
 //                 it's OK if the string is ONLY indentation
-export var indentLevel = function(line, oneIndent = undef) {
-  var lMatches, len, level, prefix, prefixLen;
+export var indentLevel = (line, oneIndent = undef) => {
+  var ch, lMatches, len, level, prefix, prefixLen;
   assert(isString(line), "not a string");
   // --- This will always match, and it's greedy
-  if (lMatches = line.match(/^(\s*)/)) {
-    prefix = lMatches[1];
+  if (lMatches = line.match(/^\s*/)) {
+    prefix = lMatches[0];
     prefixLen = prefix.length;
   }
   if (prefixLen === 0) {
     return 0;
   }
   if (defined(oneIndent)) {
+    // --- prefix must be some multiple of oneIndent
     len = oneIndent.length;
+    assert(prefixLen % len === 0, `prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
+    level = prefixLen / len;
   } else {
-    oneIndent = "\t";
-    len = 1;
-  }
-  if (prefixLen % len !== 0) {
-    croak(`prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
-  }
-  level = prefixLen / len;
-  if (prefix !== oneIndent.repeat(level)) {
-    croak(`prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
+    ch = prefix.substring(0, 1);
+    if (ch === "\t") {
+      oneIndent = "\t";
+      level = prefixLen;
+    } else if (ch === ' ') {
+      oneIndent = ' '.repeat(prefixLen);
+      level = 1;
+    } else {
+      croak(`Bad Indentation in ${OL(line)}`);
+    }
   }
+  assert(prefix === oneIndent.repeat(level), `prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
   return level;
 };
 
 // ---------------------------------------------------------------------------
 //   isUndented - true iff indentLevel(line) == 0
-export var isUndented = function(line) {
-  var lMatches;
+export var isUndented = (line) => {
   assert(isString(line), `non-string ${OL(line)}`);
-  lMatches = line.match(/^\s*/);
-  return lMatches[0].length === 0;
+  return notdefined(line.match(/^\s/));
 };
 
 // ---------------------------------------------------------------------------
 //   indented - add indentation to each string in a block or array
 //            - returns the same type as input, i.e. array or string
-export var indented = function(input, level = 1, oneIndent = "\t") {
+export var indented = (input, level = 1, oneIndent = "\t") => {
   var i, lLines, len1, line, ref, toAdd;
   // --- level can be a string, in which case it is
   //     pre-pended to each line of input
@@ -142,7 +145,7 @@ export var indented = function(input, level = 1, oneIndent = "\t") {
 //            - unless level is set, in which case exactly that
 //              indentation is removed
 //            - returns same type as text, i.e. either string or array
-export var undented = function(input, level = undef, oneIndent = "\t") {
+export var undented = (input, level = undef, oneIndent = "\t") => {
   var i, lLines, lMatches, lNewLines, len1, line, nToRemove, toRemove;
   if (defined(level) && (level === 0)) {
     return input;
@@ -185,6 +188,6 @@ export var undented = function(input, level = undef, oneIndent = "\t") {
 
 // ---------------------------------------------------------------------------
 //    enclose - indent text, surround with pre and post
-export var enclose = function(text, pre, post, oneIndent = "\t") {
+export var enclose = (text, pre, post, oneIndent = "\t") => {
   return toBlock([pre, indented(text, 1, oneIndent), post]);
 };

package/src/server.coffee

@@ -6,7 +6,7 @@ import {execSync} from 'child_process'
 # ---------------------------------------------------------------------------
 #   exec - run external commands
 
-export exec = (cmd) ->
+export exec = (cmd) =>
 
 	buffer = execSync cmd, {
 		windowsHide: true
@@ -17,7 +17,7 @@ export exec = (cmd) ->
 #   ask - ask a question
 #         later, on a web page, prompt the user for answer to question
 
-export ask = (prompt) ->
+export ask = (prompt) =>
 
 	answer = getline.question("{prompt}? ")
 	return answer

package/src/server.js

@@ -8,7 +8,7 @@ import {
 
 // ---------------------------------------------------------------------------
 //   exec - run external commands
-export var exec = function(cmd) {
+export var exec = (cmd) => {
   var buffer;
   buffer = execSync(cmd, {
     windowsHide: true
@@ -19,7 +19,7 @@ export var exec = function(cmd) {
 // ---------------------------------------------------------------------------
 //   ask - ask a question
 //         later, on a web page, prompt the user for answer to question
-export var ask = function(prompt) {
+export var ask = (prompt) => {
   var answer;
   answer = getline.question("{prompt}? ");
   return answer;

package/src/svelte.coffee

@@ -7,7 +7,7 @@ import {isFunction} from '@jdeighan/base-utils'
 # ---------------------------------------------------------------------------
 #   svelteSourceCodeEsc - to display source code for a *.starbucks page
 
-export svelteSourceCodeEsc = (str) ->
+export svelteSourceCodeEsc = (str) =>
 
 	return str \
 		.replace(/\</g, '&lt;') \
@@ -19,7 +19,7 @@ export svelteSourceCodeEsc = (str) ->
 # ---------------------------------------------------------------------------
 #   svelteHtmlEsc - after converting markdown
 
-export svelteHtmlEsc = (str) ->
+export svelteHtmlEsc = (str) =>
 
 	return str \
 		.replace(/\{/g, '&lbrace;') \
@@ -28,7 +28,7 @@ export svelteHtmlEsc = (str) ->
 
 # ---------------------------------------------------------------------------
 
-export onInterval = (func, secs, doLog=false) ->
+export onInterval = (func, secs, doLog=false) =>
 
 	assert isFunction(func), "onInterval(): 1st arg not a function"
 	ms = Math.floor(1000 * secs)

package/src/svelte.js

@@ -15,18 +15,18 @@ import {
 
 // ---------------------------------------------------------------------------
 //   svelteSourceCodeEsc - to display source code for a *.starbucks page
-export var svelteSourceCodeEsc = function(str) {
+export var svelteSourceCodeEsc = (str) => {
   return str.replace(/\</g, '&lt;').replace(/\>/g, '&gt;').replace(/\{/g, '&lbrace;').replace(/\}/g, '&rbrace;').replace(/\$/g, '&dollar;');
 };
 
 // ---------------------------------------------------------------------------
 //   svelteHtmlEsc - after converting markdown
-export var svelteHtmlEsc = function(str) {
+export var svelteHtmlEsc = (str) => {
   return str.replace(/\{/g, '&lbrace;').replace(/\}/g, '&rbrace;').replace(/\$/g, '&dollar;');
 };
 
 // ---------------------------------------------------------------------------
-export var onInterval = function(func, secs, doLog = false) {
+export var onInterval = (func, secs, doLog = false) => {
   var interval, ms;
   assert(isFunction(func), "onInterval(): 1st arg not a function");
   ms = Math.floor(1000 * secs);