@jdeighan/coffee-utils 10.0.2 → 10.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "10.0.2",
+	"version": "10.0.5",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -12,6 +12,7 @@
 		"./log": "./src/log_utils.js",
 		"./block": "./src/block_utils.js",
 		"./indent": "./src/indent_utils.js",
+		"./html": "./src/html_utils.js",
 		"./stack": "./src/call_stack.js",
 		"./debug": "./src/debug_utils.js",
 		"./arrow": "./src/arrow.js",

package/src/SectionMap.coffee

@@ -10,6 +10,7 @@ import {arrayToBlock} from '@jdeighan/coffee-utils/block'
 import {indented} from '@jdeighan/coffee-utils/indent'
 import {LOG} from '@jdeighan/coffee-utils/log'
 import {debug} from '@jdeighan/coffee-utils/debug'
+import {isTAML, taml} from '@jdeighan/coffee-utils/taml'
 import {Section} from '@jdeighan/coffee-utils/section'
 
 # ---------------------------------------------------------------------------
@@ -32,6 +33,10 @@ export class SectionMap
 		# --- lSectionTree is a tree of section/set names
 
 		debug "enter SectionMap()", @lSectionTree
+
+		if isTAML(@lSectionTree)
+			@SectionTree = taml(@lSectionTree)
+
 		assert isArray(@lSectionTree), "not an array"
 
 		# --- keys are section names, values are Section objects
@@ -97,33 +102,41 @@ export class SectionMap
 			hReplacers = desc
 			desc = @lSectionTree
 		else if notdefined(desc)
+			debug "desc is entire tree"
 			desc = @lSectionTree
 
 		if isArray(desc)
+			debug "item is an array"
 			lBlocks = []
 			setName = undef
 			for item in desc
 				subBlock = undef
-				if isArray(item)
-					subBlock = @getBlock(item, hReplacers)
-				else if isSectionName(item)
-					subBlock = @getBlock(item, hReplacers)
-				else if isSetName(item)
+				if isSetName(item)
+					debug "set name is #{item}"
 					setName = item
-				else if isString(item)
-					subBlock = item   # a literal string
+				else if isSectionName(item) || isArray(item)
+					subBlock = @getBlock(item, hReplacers)
+					if defined(subBlock)
+						debug "add subBlock", subBlock
+						lBlocks.push subBlock
+					else
+						debug "subBlock is undef"
+				else if isString(item) && nonEmpty(item)
+					debug "add string", item
+					lBlocks.push item
 				else
 					croak "Bad item: #{OL(item)}"
-				if defined(subBlock)
-					lBlocks.push subBlock
+
 			block = arrayToBlock(lBlocks)
+			debug "block is", block
 			if defined(setName)
 				if defined(proc = hReplacers[setName])
-					debug "REPLACE #{setName}"
 					block = proc(block)
+					debug "REPLACE #{setName} with", block
 				else
 					debug "NO REPLACER for #{setName}"
 		else if isSectionName(desc)
+			debug "item is a section name"
 			block = @section(desc).getBlock()
 			if defined(proc = hReplacers[desc])
 				debug "REPLACE #{desc}"
@@ -131,7 +144,7 @@ export class SectionMap
 			else
 				debug "NO REPLACER for #{desc}"
 		else if isSetName(desc)
-			# --- pass array to getBlock()
+			debug "item is a set name"
 			block = @getBlock(@hSets[desc], hReplacers)
 		else
 			croak "Bad 1st arg: #{OL(desc)}"

package/src/SectionMap.js

@@ -40,6 +40,11 @@ import {
   debug
 } from '@jdeighan/coffee-utils/debug';
 
+import {
+  isTAML,
+  taml
+} from '@jdeighan/coffee-utils/taml';
+
 import {
   Section
 } from '@jdeighan/coffee-utils/section';
@@ -60,6 +65,9 @@ export var SectionMap = class SectionMap {
     this.lSectionTree = lSectionTree;
     // --- lSectionTree is a tree of section/set names
     debug("enter SectionMap()", this.lSectionTree);
+    if (isTAML(this.lSectionTree)) {
+      this.SectionTree = taml(this.lSectionTree);
+    }
     assert(isArray(this.lSectionTree), "not an array");
     // --- keys are section names, values are Section objects
     this.hSections = {};
@@ -126,39 +134,46 @@ export var SectionMap = class SectionMap {
       hReplacers = desc;
       desc = this.lSectionTree;
     } else if (notdefined(desc)) {
+      debug("desc is entire tree");
       desc = this.lSectionTree;
     }
     if (isArray(desc)) {
+      debug("item is an array");
       lBlocks = [];
       setName = undef;
       for (i = 0, len = desc.length; i < len; i++) {
         item = desc[i];
         subBlock = undef;
-        if (isArray(item)) {
-          subBlock = this.getBlock(item, hReplacers);
-        } else if (isSectionName(item)) {
-          subBlock = this.getBlock(item, hReplacers);
-        } else if (isSetName(item)) {
+        if (isSetName(item)) {
+          debug(`set name is ${item}`);
           setName = item;
-        } else if (isString(item)) {
-          subBlock = item; // a literal string
+        } else if (isSectionName(item) || isArray(item)) {
+          subBlock = this.getBlock(item, hReplacers);
+          if (defined(subBlock)) {
+            debug("add subBlock", subBlock);
+            lBlocks.push(subBlock);
+          } else {
+            debug("subBlock is undef");
+          }
+        } else if (isString(item) && nonEmpty(item)) {
+          debug("add string", item);
+          lBlocks.push(item);
         } else {
           croak(`Bad item: ${OL(item)}`);
         }
-        if (defined(subBlock)) {
-          lBlocks.push(subBlock);
-        }
       }
       block = arrayToBlock(lBlocks);
+      debug("block is", block);
       if (defined(setName)) {
         if (defined(proc = hReplacers[setName])) {
-          debug(`REPLACE ${setName}`);
           block = proc(block);
+          debug(`REPLACE ${setName} with`, block);
         } else {
           debug(`NO REPLACER for ${setName}`);
         }
       }
     } else if (isSectionName(desc)) {
+      debug("item is a section name");
       block = this.section(desc).getBlock();
       if (defined(proc = hReplacers[desc])) {
         debug(`REPLACE ${desc}`);
@@ -167,7 +182,7 @@ export var SectionMap = class SectionMap {
         debug(`NO REPLACER for ${desc}`);
       }
     } else if (isSetName(desc)) {
-      // --- pass array to getBlock()
+      debug("item is a set name");
       block = this.getBlock(this.hSets[desc], hReplacers);
     } else {
       croak(`Bad 1st arg: ${OL(desc)}`);

package/src/coffee_utils.coffee

@@ -33,14 +33,6 @@ export pass = () ->
 
 # ---------------------------------------------------------------------------
 
-export getClassName = (obj) ->
-
-	if (typeof obj != 'object')
-		return undef
-	return obj.constructor.name
-
-# ---------------------------------------------------------------------------
-
 export patchStr = (bigstr, pos, str) ->
 
 	endpos = pos + str.length
@@ -62,6 +54,55 @@ export charCount = (str, ch) ->
 
 # ---------------------------------------------------------------------------
 
+export isConstructor = (f) ->
+
+	try
+		new f()
+	catch err
+		if (err.message.indexOf('is not a constructor') >= 0)
+			return false;
+	return true;
+
+# ---------------------------------------------------------------------------
+
+export jsType = (x) ->
+
+	if notdefined(x)
+		return [undef, undef]
+	else if isString(x)
+		if x.match(/^\s*$/)
+			return ['string', 'empty']
+		else
+			return ['string', undef]
+	else if isNumber(x)
+		if Number.isInteger(x)
+			return ['number', 'integer']
+		else
+			return ['number', undef]
+	else if isBoolean(x)
+		return ['boolean', undef]
+	else if isHash(x)
+		lKeys = Object.keys(x);
+		if (lKeys.length == 0)
+			return ['hash', 'empty']
+		else
+			return ['hash', undef]
+	else if isArray(x)
+		if (x.length == 0)
+			return ['array', 'empty']
+		else
+			return ['array', undef]
+	else if isConstructor(x)
+		return ['function', 'constructor']
+	else if isFunction(x)
+		return ['function', undef]
+	else if isObject(x)
+		return ['object', undef]
+	else
+		croak "Unknown type: #{OL(x)}"
+
+# ---------------------------------------------------------------------------
+
 export isString = (x) ->
 
 	return (typeof x == 'string') || (x instanceof String)
@@ -94,6 +135,14 @@ export isObject = (x) ->
 
 # ---------------------------------------------------------------------------
 
+export getClassName = (obj) ->
+
+	if (typeof obj != 'object')
+		return undef
+	return obj.constructor.name
+
+# ---------------------------------------------------------------------------
+
 export isArray = (x) ->
 
 	return Array.isArray(x)
@@ -207,13 +256,15 @@ export isRegExp = (x) ->
 
 # ---------------------------------------------------------------------------
 
-export isNumber = (x, hOptions={}) ->
+export isNumber = (x, hOptions=undef) ->
 
 	result = (typeof x == 'number') || (x instanceof Number)
-	if result
-		if defined(hOptions.min) && (x < hOptions.min)
+	if result && defined(hOptions)
+		assert isHash(hOptions), "2nd arg not a hash: #{OL(hOptions)}"
+		{min, max} = hOptions
+		if defined(min) && (x < min)
 			result = false
-		if defined(hOptions.max) && (x > hOptions.max)
+		if defined(max) && (x > max)
 			result = false
 	return result
 

package/src/coffee_utils.js

@@ -37,14 +37,6 @@ export var eval_expr = function(str) {
 //   pass - do nothing
 export var pass = function() {};
 
-// ---------------------------------------------------------------------------
-export var getClassName = function(obj) {
-  if (typeof obj !== 'object') {
-    return undef;
-  }
-  return obj.constructor.name;
-};
-
 // ---------------------------------------------------------------------------
 export var patchStr = function(bigstr, pos, str) {
   var endpos;
@@ -68,6 +60,63 @@ export var charCount = function(str, ch) {
   return count;
 };
 
+// ---------------------------------------------------------------------------
+export var isConstructor = function(f) {
+  var err;
+  try {
+    new f();
+  } catch (error1) {
+    err = error1;
+    if (err.message.indexOf('is not a constructor') >= 0) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// ---------------------------------------------------------------------------
+export var jsType = function(x) {
+  var lKeys;
+  if (notdefined(x)) {
+    return [undef, undef];
+  } else if (isString(x)) {
+    if (x.match(/^\s*$/)) {
+      return ['string', 'empty'];
+    } else {
+      return ['string', undef];
+    }
+  } else if (isNumber(x)) {
+    if (Number.isInteger(x)) {
+      return ['number', 'integer'];
+    } else {
+      return ['number', undef];
+    }
+  } else if (isBoolean(x)) {
+    return ['boolean', undef];
+  } else if (isHash(x)) {
+    lKeys = Object.keys(x);
+    if (lKeys.length === 0) {
+      return ['hash', 'empty'];
+    } else {
+      return ['hash', undef];
+    }
+  } else if (isArray(x)) {
+    if (x.length === 0) {
+      return ['array', 'empty'];
+    } else {
+      return ['array', undef];
+    }
+  } else if (isConstructor(x)) {
+    return ['function', 'constructor'];
+  } else if (isFunction(x)) {
+    return ['function', undef];
+  } else if (isObject(x)) {
+    return ['object', undef];
+  } else {
+    return croak(`Unknown type: ${OL(x)}`);
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var isString = function(x) {
   return (typeof x === 'string') || (x instanceof String);
@@ -94,6 +143,14 @@ export var isObject = function(x) {
   return (typeof x === 'object') && !isString(x) && !isArray(x) && !isHash(x) && !isNumber(x);
 };
 
+// ---------------------------------------------------------------------------
+export var getClassName = function(obj) {
+  if (typeof obj !== 'object') {
+    return undef;
+  }
+  return obj.constructor.name;
+};
+
 // ---------------------------------------------------------------------------
 export var isArray = function(x) {
   return Array.isArray(x);
@@ -220,14 +277,16 @@ export var isRegExp = function(x) {
 };
 
 // ---------------------------------------------------------------------------
-export var isNumber = function(x, hOptions = {}) {
-  var result;
+export var isNumber = function(x, hOptions = undef) {
+  var max, min, result;
   result = (typeof x === 'number') || (x instanceof Number);
-  if (result) {
-    if (defined(hOptions.min) && (x < hOptions.min)) {
+  if (result && defined(hOptions)) {
+    assert(isHash(hOptions), `2nd arg not a hash: ${OL(hOptions)}`);
+    ({min, max} = hOptions);
+    if (defined(min) && (x < min)) {
       result = false;
     }
-    if (defined(hOptions.max) && (x > hOptions.max)) {
+    if (defined(max) && (x > max)) {
       result = false;
     }
   }

package/src/html_utils.coffee

@@ -0,0 +1,217 @@
+# html_utils.coffee
+
+import {assert, croak} from '@jdeighan/unit-tester/utils'
+import {
+	undef, pass, words, isEmpty, nonEmpty,
+	} from '@jdeighan/coffee-utils'
+import {indented, enclose} from '@jdeighan/coffee-utils/indent'
+import {arrayToBlock} from '@jdeighan/coffee-utils/block'
+import {debug} from '@jdeighan/coffee-utils/debug'
+
+hNoEnd = {}
+for tagName in words('area base br col command embed hr img input' \
+		+ ' keygen link meta param source track wbr')
+	hNoEnd[tagName] = true
+
+# ---------------------------------------------------------------------------
+
+export parsetag = (line) ->
+
+	if lMatches = line.match(///^
+			(?:
+				([A-Za-z][A-Za-z0-9_]*)  # variable name
+				\s*
+				=
+				\s*
+				)?                       # variable is optional
+			([A-Za-z][A-Za-z0-9_]*)     # tag name
+			(?:
+				\:
+				( [a-z]+ )
+				)?
+			(\S*)                       # modifiers (class names, etc.)
+			\s*
+			(.*)                        # attributes & enclosed text
+			$///)
+		[_, varName, tagName, subtype, modifiers, rest] = lMatches
+	else
+		croak "parsetag(): Invalid HTML: '#{line}'"
+
+	# --- Handle classes - subtypes and added via .<class>
+	lClasses = []
+	if nonEmpty(subtype) && (tagName != 'svelte')
+		lClasses.push subtype
+
+	if modifiers
+		# --- currently, these are only class names
+		while lMatches = modifiers.match(///^
+				\. ([A-Za-z][A-Za-z0-9_]*)
+				///)
+			[all, className] = lMatches
+			lClasses.push className
+			modifiers = modifiers.substring(all.length)
+		if modifiers
+			croak "parsetag(): Invalid modifiers in '#{line}'"
+
+	# --- Handle attributes
+	hAttr = {}     # { name: { value: <value>, quote: <quote> }, ... }
+
+	if varName
+		hAttr['bind:this'] = {value: varName, quote: '{'}
+
+	if (tagName == 'script') && (subtype == 'startup')
+		hAttr['context'] = {value: 'module', quote: '"'}
+
+	if rest
+		while lMatches = rest.match(///^
+				(?:
+					(?:
+						(?:
+							( bind | on )          # prefix
+							:
+							)?
+						([A-Za-z][A-Za-z0-9_]*)   # attribute name
+						)
+					=
+					(?:
+						  \{ ([^}]*) \}           # attribute value
+						| " ([^"]*) "
+						| ' ([^']*) '
+						|   ([^"'\s]+)
+						)
+					|
+					\{
+					([A-Za-z][A-Za-z0-9_]*)
+					\}
+					) \s*
+				///)
+			[all, prefix, attrName, br_val, dq_val, sq_val, uq_val, ident] = lMatches
+			if ident
+				hAttr[ident] = { value: ident, shorthand: true }
+			else
+				if br_val
+					value = br_val
+					quote = '{'
+				else
+					assert ! prefix?, "prefix requires use of {...}"
+					if dq_val
+						value = dq_val
+						quote = '"'
+					else if sq_val
+						value = sq_val
+						quote = "'"
+					else
+						value = uq_val
+						quote = ''
+
+				if prefix
+					attrName = "#{prefix}:#{attrName}"
+
+				if attrName == 'class'
+					for className in value.split(/\s+/)
+						lClasses.push className
+				else
+					if hAttr.attrName?
+						croak "parsetag(): Multiple attributes named '#{attrName}'"
+					hAttr[attrName] = { value, quote }
+
+			rest = rest.substring(all.length)
+
+	# --- The rest is contained text
+	rest = rest.trim()
+	if lMatches = rest.match(///^
+			['"]
+			(.*)
+			['"]
+			$///)
+		rest = lMatches[1]
+
+	# --- Add class attribute to hAttr if there are classes
+	if (lClasses.length > 0)
+		hAttr.class = {
+			value: lClasses.join(' '),
+			quote: '"',
+			}
+
+	# --- Build the return value
+	hToken = {
+		type: 'tag'
+		tagName
+		}
+
+	if subtype
+		hToken.subtype = subtype
+		hToken.orgtag = "#{tagName}:#{subtype}"
+	else
+		hToken.orgtag = tagName
+
+	# --- if tagName == 'svelte', set hToken.tagName to hToken.orgtag
+	if (tagName == 'svelte')
+		hToken.tagName = hToken.orgtag
+
+	if nonEmpty(hAttr)
+		hToken.hAttr = hAttr
+
+	# --- Is there contained text?
+	if rest
+		hToken.text = rest
+
+	return hToken
+
+# ---------------------------------------------------------------------------
+# --- export only for unit testing
+
+export attrStr = (hAttr) ->
+
+	if ! hAttr
+		return ''
+	str = ''
+	for attrName in Object.getOwnPropertyNames(hAttr)
+		{value, quote, shorthand} = hAttr[attrName]
+		if shorthand
+			str += " {#{value}}"
+		else
+			if quote == '{'
+				bquote = '{'
+				equote = '}'
+			else
+				bquote = equote = quote
+			str += " #{attrName}=#{bquote}#{value}#{equote}"
+	return str
+
+# ---------------------------------------------------------------------------
+
+export tag2str = (hToken, type='begin') ->
+
+	{tagName, hAttr} = hToken
+	if (type == 'begin')
+		str = "<#{tagName}"    # build the string bit by bit
+		if nonEmpty(hAttr)
+			str += attrStr(hAttr)
+		str += '>'
+		return str
+	else if (type == 'end')
+		if hNoEnd[tagName]
+			return undef
+		else
+			return "</#{tagName}>"
+	else
+		croak "type must be 'begin' or 'end'"
+
+# ---------------------------------------------------------------------------
+#    elem - indent text, surround with HTML tags
+
+export elem = (tagName, hAttr=undef, text=undef, oneIndent="\t") ->
+
+	if isEmpty(text)
+		return undef
+	hToken = {
+		tagName
+		hAttr
+		text
+		}
+	return arrayToBlock([
+		tag2str(hToken, 'begin')
+		indented(text, 1, oneIndent)
+		tag2str(hToken, 'end')
+		])

package/src/html_utils.js

@@ -0,0 +1,222 @@
+// Generated by CoffeeScript 2.7.0
+// html_utils.coffee
+var hNoEnd, i, len, ref, tagName;
+
+import {
+  assert,
+  croak
+} from '@jdeighan/unit-tester/utils';
+
+import {
+  undef,
+  pass,
+  words,
+  isEmpty,
+  nonEmpty
+} from '@jdeighan/coffee-utils';
+
+import {
+  indented,
+  enclose
+} from '@jdeighan/coffee-utils/indent';
+
+import {
+  arrayToBlock
+} from '@jdeighan/coffee-utils/block';
+
+import {
+  debug
+} from '@jdeighan/coffee-utils/debug';
+
+hNoEnd = {};
+
+ref = words('area base br col command embed hr img input' + ' keygen link meta param source track wbr');
+for (i = 0, len = ref.length; i < len; i++) {
+  tagName = ref[i];
+  hNoEnd[tagName] = true;
+}
+
+// ---------------------------------------------------------------------------
+export var parsetag = function(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
+    // tag name
+    // modifiers (class names, etc.)
+    // attributes & enclosed text
+    [_, varName, tagName, subtype, modifiers, rest] = lMatches;
+  } else {
+    croak(`parsetag(): Invalid HTML: '${line}'`);
+  }
+  // --- Handle classes - subtypes and added via .<class>
+  lClasses = [];
+  if (nonEmpty(subtype) && (tagName !== 'svelte')) {
+    lClasses.push(subtype);
+  }
+  if (modifiers) {
+    // --- currently, these are only class names
+    while (lMatches = modifiers.match(/^\.([A-Za-z][A-Za-z0-9_]*)/)) {
+      [all, className] = lMatches;
+      lClasses.push(className);
+      modifiers = modifiers.substring(all.length);
+    }
+    if (modifiers) {
+      croak(`parsetag(): Invalid modifiers in '${line}'`);
+    }
+  }
+  // --- Handle attributes
+  hAttr = {}; // { name: { value: <value>, quote: <quote> }, ... }
+  if (varName) {
+    hAttr['bind:this'] = {
+      value: varName,
+      quote: '{'
+    };
+  }
+  if ((tagName === 'script') && (subtype === 'startup')) {
+    hAttr['context'] = {
+      value: 'module',
+      quote: '"'
+    };
+  }
+  if (rest) {
+    while (lMatches = rest.match(/^(?:(?:(?:(bind|on):)?([A-Za-z][A-Za-z0-9_]*))=(?:\{([^}]*)\}|"([^"]*)"|'([^']*)'|([^"'\s]+))|\{([A-Za-z][A-Za-z0-9_]*)\})\s*/)) { // prefix
+      // attribute name
+      // attribute value
+      [all, prefix, attrName, br_val, dq_val, sq_val, uq_val, ident] = lMatches;
+      if (ident) {
+        hAttr[ident] = {
+          value: ident,
+          shorthand: true
+        };
+      } else {
+        if (br_val) {
+          value = br_val;
+          quote = '{';
+        } else {
+          assert(prefix == null, "prefix requires use of {...}");
+          if (dq_val) {
+            value = dq_val;
+            quote = '"';
+          } else if (sq_val) {
+            value = sq_val;
+            quote = "'";
+          } else {
+            value = uq_val;
+            quote = '';
+          }
+        }
+        if (prefix) {
+          attrName = `${prefix}:${attrName}`;
+        }
+        if (attrName === 'class') {
+          ref1 = value.split(/\s+/);
+          for (j = 0, len1 = ref1.length; j < len1; j++) {
+            className = ref1[j];
+            lClasses.push(className);
+          }
+        } else {
+          if (hAttr.attrName != null) {
+            croak(`parsetag(): Multiple attributes named '${attrName}'`);
+          }
+          hAttr[attrName] = {value, quote};
+        }
+      }
+      rest = rest.substring(all.length);
+    }
+  }
+  // --- The rest is contained text
+  rest = rest.trim();
+  if (lMatches = rest.match(/^['"](.*)['"]$/)) {
+    rest = lMatches[1];
+  }
+  // --- Add class attribute to hAttr if there are classes
+  if (lClasses.length > 0) {
+    hAttr.class = {
+      value: lClasses.join(' '),
+      quote: '"'
+    };
+  }
+  // --- Build the return value
+  hToken = {
+    type: 'tag',
+    tagName
+  };
+  if (subtype) {
+    hToken.subtype = subtype;
+    hToken.orgtag = `${tagName}:${subtype}`;
+  } else {
+    hToken.orgtag = tagName;
+  }
+  // --- if tagName == 'svelte', set hToken.tagName to hToken.orgtag
+  if (tagName === 'svelte') {
+    hToken.tagName = hToken.orgtag;
+  }
+  if (nonEmpty(hAttr)) {
+    hToken.hAttr = hAttr;
+  }
+  // --- Is there contained text?
+  if (rest) {
+    hToken.text = rest;
+  }
+  return hToken;
+};
+
+// ---------------------------------------------------------------------------
+// --- export only for unit testing
+export var attrStr = function(hAttr) {
+  var attrName, bquote, equote, j, len1, quote, ref1, shorthand, str, value;
+  if (!hAttr) {
+    return '';
+  }
+  str = '';
+  ref1 = Object.getOwnPropertyNames(hAttr);
+  for (j = 0, len1 = ref1.length; j < len1; j++) {
+    attrName = ref1[j];
+    ({value, quote, shorthand} = hAttr[attrName]);
+    if (shorthand) {
+      str += ` {${value}}`;
+    } else {
+      if (quote === '{') {
+        bquote = '{';
+        equote = '}';
+      } else {
+        bquote = equote = quote;
+      }
+      str += ` ${attrName}=${bquote}${value}${equote}`;
+    }
+  }
+  return str;
+};
+
+// ---------------------------------------------------------------------------
+export var tag2str = function(hToken, type = 'begin') {
+  var hAttr, str;
+  ({tagName, hAttr} = hToken);
+  if (type === 'begin') {
+    str = `<${tagName}`;
+    if (nonEmpty(hAttr)) {
+      str += attrStr(hAttr);
+    }
+    str += '>';
+    return str;
+  } else if (type === 'end') {
+    if (hNoEnd[tagName]) {
+      return undef;
+    } else {
+      return `</${tagName}>`;
+    }
+  } else {
+    return croak("type must be 'begin' or 'end'");
+  }
+};
+
+// ---------------------------------------------------------------------------
+//    elem - indent text, surround with HTML tags
+export var elem = function(tagName, hAttr = undef, text = undef, oneIndent = "\t") {
+  var hToken;
+  if (isEmpty(text)) {
+    return undef;
+  }
+  hToken = {tagName, hAttr, text};
+  return arrayToBlock([tag2str(hToken, 'begin'), indented(text, 1, oneIndent), tag2str(hToken, 'end')]);
+};

package/src/indent_utils.coffee

@@ -164,14 +164,3 @@ export enclose = (text, pre, post, oneIndent="\t") ->
 		indented(text, 1, oneIndent)
 		post
 		])
-
-# ---------------------------------------------------------------------------
-#    elem - indent text, surround with HTML tags
-
-export elem = (text, tag, oneIndent="\t") ->
-
-	return arrayToBlock([
-		"<#{tag}>"
-		indented(text, 1, oneIndent)
-		"</#{tag}>"
-		])

package/src/indent_utils.js

@@ -187,9 +187,3 @@ export var untabify = function(str, numSpaces = 3) {
 export var enclose = function(text, pre, post, oneIndent = "\t") {
   return arrayToBlock([pre, indented(text, 1, oneIndent), post]);
 };
-
-// ---------------------------------------------------------------------------
-//    elem - indent text, surround with HTML tags
-export var elem = function(text, tag, oneIndent = "\t") {
-  return arrayToBlock([`<${tag}>`, indented(text, 1, oneIndent), `</${tag}>`]);
-};

package/src/log_utils.coffee

@@ -183,7 +183,12 @@ export logItem = (label, item, pre='', itemPre=undef) ->
 		putstr "#{pre}#{labelStr}#{item}"
 	else if isString(item)
 		if (item.length <= maxOneLine)
-			putstr "#{pre}#{labelStr}'#{escapeStr(item)}'"
+			result = escapeStr(item)
+			hasApos = (result.indexOf("'") >= 0)
+			if hasApos
+				putstr "#{pre}#{labelStr}\"#{result}\""
+			else
+				putstr "#{pre}#{labelStr}'#{result}'"
 		else
 			if label
 				putstr "#{pre}#{label}:"

package/src/log_utils.js

@@ -184,7 +184,7 @@ export var logBareItem = function(item, pre = '') {
 
 // ---------------------------------------------------------------------------
 export var logItem = function(label, item, pre = '', itemPre = undef) {
-  var i, labelStr, len, ref, str;
+  var hasApos, i, labelStr, len, ref, result, str;
   assert(isString(pre), `not a string: ${OL(pre)}`);
   assert(isFunction(putstr), "putstr not properly set");
   assert(!label || isString(label), "label a non-string");
@@ -207,7 +207,13 @@ export var logItem = function(label, item, pre = '', itemPre = undef) {
     putstr(`${pre}${labelStr}${item}`);
   } else if (isString(item)) {
     if (item.length <= maxOneLine) {
-      putstr(`${pre}${labelStr}'${escapeStr(item)}'`);
+      result = escapeStr(item);
+      hasApos = result.indexOf("'") >= 0;
+      if (hasApos) {
+        putstr(`${pre}${labelStr}\"${result}\"`);
+      } else {
+        putstr(`${pre}${labelStr}'${result}'`);
+      }
     } else {
       if (label) {
         putstr(`${pre}${label}:`);