@effectful/transducers-loose/v2/debug.js

@effectful/transducers built with faster generators

"use strict";

exports.__esModule = true;
exports.ccg = ccg;
exports.cg = cg;
exports.cleanComments = cleanComments;
exports.color = void 0;
exports.copyComment = copyComment;
exports.dumpToConsole = exports.dumpDoc = void 0;
exports.dumpToStr = dumpToStr;
exports.fin = void 0;
exports.markNodeType = markNodeType;
exports.setComment = setComment;
exports.setEndComment = setEndComment;
exports.tempNames = tempNames;
exports.tempNamesRange = tempNamesRange;
exports.traceLazy = exports.traceDoc = exports.traceAll = void 0;
exports.verify = verify;
var _generator = require("@babel/generator");
var T = require("@babel/types");
var _config = require("./config");
var _types2 = require("./types");
var _combinators = require("./combinators");
var _core = require("./core");
var M = require("@effectful/es-rt/opts/loose");
const MAX_TRACE_CODE_LEN = 40;
const enterStyles = "background: #222; color: #bada55;font-size:1.5em";
const leaveStyles = "color: #ee5757; background: black";
const newTagStyle = "color:purple;font-size:large";
const positionStyle = "color:gray;text-decoration:underline";
const dirStyle = "font-size:x-large;font-weight:bolder";
function defaultReplacer(n, v) {
  return n === "leadingComments" || n === "trailingComments" ? void 0 : v;
}

/**
 * outputs short description of AST node
 */
function cg(ast, opts = {}) {
  var res;
  if (ast == null) {
    // console.error("<NULL>")
    return "<NULL>";
  }
  try {
    if (Array.isArray(ast)) {
      ast = ast.length > 0 && T.isExpression(ast[0]) ? T.sequenceExpression(ast) : T.blockStatement(ast);
    }
    res = (0, _generator.default)(ast, opts, "").code;
  } catch (e) {
    if (ast.type != null) console.log("ERROR:", e.stack);
  }
  if (res != null) {
    return res;
  }
  return "!!" + opts.compact ? JSON.stringify(ast, defaultReplacer) : JSON.stringify(ast, defaultReplacer, 2);
}

/**
 * same as `cg` but using compact syntax
 */
function ccg(ast) {
  return cg(ast, {
    compact: true
  });
}
if (_config.default.debug) {
  global.cg = cg;
  global.ccg = ccg;
}
function verify(s) {
  var stack,
    start,
    i,
    ti,
    ctrlPos,
    f,
    keys,
    k,
    _keys,
    _f,
    verify = M.generator(),
    loop,
    r,
    p;
  verify.step = verify_1;
  verify.$step = 3;
  return verify;
  function verify_1(p) {
    for (;;) {
      switch (verify.$cur = verify.$step) {
        case 3:
          stack = [];
          loop = M.iterator((0, _core.hier)((0, _core.dft)((0, _core.resetFieldInfo)((0, _core.fromIterable)(s)))));
          verify.$step = 4;
          verify.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            ({
              start,
              value: i
            } = loop.value);
            ti = (0, _types2.typeInfo)(i);
            ctrlPos = (0, _types2.symInfo)(i.pos).kind === "ctrl";
            if (start) {
              if (stack.length) {
                [f, keys] = stack[stack.length - 1];
                if (f.type === _types2.Tag.Array) {
                  if (!ctrlPos) {}
                } else {
                  if (keys != null && !ctrlPos) {
                    k = void 0;
                    while ((k = keys.shift()) != null) {
                      if (_types2.Tag[k] === i.pos) {
                        break;
                      }
                    }
                  }
                }
              }
              if (i.fieldInfo != null) {
                if (i.type === _types2.Tag.Array) {}
              }
              _keys = T.VISITOR_KEYS[(0, _types2.symName)(i.type)];
              stack.push([i, _keys && [..._keys]]);
              verify.$step = 4;
              verify.value = i;
              return verify;
            } else {
              [_f] = stack.pop();
              if (ti.kind !== "ctrl") {}
              verify.$step = 4;
              verify.$step = 4;
              continue;
            }
          } else {
            verify.$step = 0;
            verify.value = void 0;
            verify.done = true;
            return verify;
          }
        case 0:
          verify.$step = 0;
          verify.value = p;
          verify.done = true;
          return verify;
        case 1:
          verify.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
function pad(s) {
  if (s.length % 2) s += " ";
  const sps = Array(Math.max(20 - s.length / 2, 2)).join(" ");
  return sps + s + sps;
}
const traceImpl = _config.default.color ? browserTraceImpl : traceNodeImpl;
function traceDocImpl(prefix, root) {
  (0, _core.skip)(traceImpl(prefix, (0, _core.dft)(root)));
  return root;
}
function traceNodeImpl(prefix, s) {
  var x,
    chalk,
    start,
    i,
    dir,
    clevel,
    descr,
    n,
    node,
    comments,
    commentsTxt,
    t,
    loc,
    f,
    _s,
    e,
    traceNodeImpl = M.generator(),
    loop,
    r,
    p;
  traceNodeImpl.step = traceNodeImpl_1;
  traceNodeImpl.$step = 3;
  return traceNodeImpl;
  function traceNodeImpl_1(p) {
    for (;;) {
      switch (traceNodeImpl.$cur = traceNodeImpl.$step) {
        case 3:
          x = 0;
          chalk = require("chalk");
          loop = M.iterator((0, _core.hier)(s));
          traceNodeImpl.$step = 4;
          traceNodeImpl.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            ({
              start,
              value: i
            } = loop.value);
            dir = chalk.bold(start ? "\\" : "/");
            clevel = `${i.level}`;
            descr = `${chalk.green((0, _types2.symName)(i.pos))}:${i.type.ctrl ? chalk.green((0, _types2.symName)(i.type)) : chalk.green.bold((0, _types2.symName)(i.type))}[${clevel}]`;
            n = "";
            ({
              node
            } = i);
            comments = [];
            commentsTxt = "";
            t = [].concat(i.comments || [], i.tcomments || []);
            if (t.length) {
              if (comments.length) {
                commentsTxt = chalk.bold("[") + comments.join(" ") + chalk.bold("]");
              }
            }
            if (node != null && i.type !== _types2.Tag.Array && (0, _types2.symKind)(i.type) !== "ctrl") {
              n = ccg(node);
              if (n.length > MAX_TRACE_CODE_LEN) {
                n = n.substr(0, MAX_TRACE_CODE_LEN) + "...";
              }
              n = chalk.yellow(n);
              ({
                loc
              } = node);
              if (loc != null) {
                ({
                  source: f,
                  start: _s,
                  end: e
                } = loc);
                n += chalk.blue(` @${f || "?"}-${_s.line}:${_s.column}..${e.line}:${e.column}`);
              } else {
                n += chalk.bold(" @new");
              }
            }
            console.log(prefix, Array(i.level).join(" "), dir, `${descr}@${x}`, commentsTxt, n);
            if (start) {
              traceNodeImpl.$step = 5;
              traceNodeImpl.value = i;
              return traceNodeImpl;
            } else {
              traceNodeImpl.$step = 5;
              traceNodeImpl.$step = 5;
              continue;
            }
          } else {
            console.log(prefix, "len:", x);
            traceNodeImpl.$step = 0;
            traceNodeImpl.value = void 0;
            traceNodeImpl.done = true;
            return traceNodeImpl;
          }
        case 5:
          x++;
          traceNodeImpl.$step = 4;
          traceNodeImpl.$step = 4;
          continue;
        case 0:
          traceNodeImpl.$step = 0;
          traceNodeImpl.value = p;
          traceNodeImpl.done = true;
          return traceNodeImpl;
        case 1:
          traceNodeImpl.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
function browserTraceImpl(prefix, s) {
  var x,
    first,
    start,
    i,
    name,
    styles,
    dir,
    clevel,
    tp,
    descr,
    idtxt,
    ldescr,
    n,
    node,
    comments,
    commentsTxt,
    t,
    pstyle,
    j,
    mod,
    _s,
    loc,
    f,
    s1,
    e,
    browserTraceImpl = M.generator(),
    loop,
    _loop,
    r,
    p;
  browserTraceImpl.step = browserTraceImpl_1;
  browserTraceImpl.$step = 3;
  return browserTraceImpl;
  function browserTraceImpl_1(p) {
    for (;;) {
      switch (browserTraceImpl.$cur = browserTraceImpl.$step) {
        case 3:
          x = 0;
          first = true;
          loop = M.iterator((0, _core.hier)(s));
          browserTraceImpl.$step = 4;
          browserTraceImpl.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            ({
              start,
              value: i
            } = loop.value);
            if (first) {
              first = false;
              name = (0, _types2.symName)(i.type);
              if (i.funcId) {
                name += ":" + i.funcId.id;
              }
              console.log(`%c${pad(prefix + " " + name.match(/[A-Z]/g).join(""))}%c`, `background:#2B81AF;color:#fff;font-size:xx-large;
                   text-shadow:rgba(0, 0, 0, 0.5) 2px 2px 1px`, "");
              if (i.parent) {
                console.log("ROOT", i.parent);
              }
              console.log("SCOPE", i);
            }
            styles = [];
            dir = start ? "\u2192" : "\u2190";
            clevel = `${i.level}`;
            tp = i.pos === i.type ? (0, _types2.symName)(i.type) : `${(0, _types2.symName)(i.pos)}:${(0, _types2.symName)(i.type)}`;
            descr = `${prefix}${tp}[${clevel}]`;
            idtxt = i.id ? `-${i.id}` : "";
            ldescr = void 0;
            if (i.pos === i.type) {
              ldescr = `${prefix}%c${(0, _types2.symName)(i.type)}%c[${clevel}]`;
              styles.push((0, _types2.symKind)(i.type) === "ctrl" ? "color:navy;font-size:large" : "color:steelblue", "");
            } else {
              ldescr = `${prefix}%c${(0, _types2.symName)(i.pos)}:%c${(0, _types2.symName)(i.type)}%c[${clevel}]`;
              styles.push((0, _types2.symKind)(i.pos) === "ctrl" ? "color:olive;font-size:large" : "color:green");
              styles.push((0, _types2.symKind)(i.type) === "ctrl" ? "color:navy;font-size:large" : "color:steelblue", "");
            }
            if (start && console.group != null) {
              if (x === 0 && i.collapsed !== false || i.collapsed) {
                console.groupCollapsed(descr);
              } else {
                console.group(descr);
              }
            }
            n = "";
            ({
              node
            } = i);
            comments = [];
            commentsTxt = "";
            t = [].concat(i.comments || [], i.tcomments || []);
            if (t.length) {
              pstyle = "color:green;font-size:large";
              styles.push(pstyle);
              _loop = M.iterator(t);
              for (; !(_loop = _loop.step()).done;) {
                j = _loop.value;
                comments.push(`%c${j.txt}%c`);
                mod = !i.enter ? "font-size:small;font-style:italic" : "font-weight:bolder;font-size:large";
                _s = `${j.style || ""}${mod}`;
                styles.push(_s, "");
              }
              if (comments.length) {
                commentsTxt = "%c[" + comments.join(" ") + "%c]%c";
                styles.push(pstyle, "");
              }
            }
            if (node != null && i.type !== _types2.Tag.Array && (0, _types2.symKind)(i.type) !== "ctrl") {
              n = ccg(node);
              if (n.length > MAX_TRACE_CODE_LEN) {
                n = n.substr(0, MAX_TRACE_CODE_LEN) + "...";
              }
              n = `%c ${n} %c`;
              styles.push(i.enter ? enterStyles : leaveStyles, "");
              ({
                loc
              } = node);
              if (loc != null) {
                ({
                  source: f,
                  start: s1,
                  end: e
                } = loc);
                n += ` %c@${f || "?"}-${s1.line}:${s1.column}..${e.line}:${e.column}%c`;
                styles.push(positionStyle, "");
              } else {
                n += " %c@new%c";
                styles.push(newTagStyle, "");
              }
            }
            console.log(`%c${dir}%c ${ldescr}@${x}${idtxt}${commentsTxt} ${n}`, dirStyle, "", ...styles, i);
            if (start) {
              browserTraceImpl.$step = 5;
              browserTraceImpl.value = i;
              return browserTraceImpl;
            } else {
              console.groupEnd();
              browserTraceImpl.$step = 5;
              browserTraceImpl.$step = 5;
              continue;
            }
          } else {
            console.log(`${prefix}len: ${x}`);
            browserTraceImpl.$step = 0;
            browserTraceImpl.value = void 0;
            browserTraceImpl.done = true;
            return browserTraceImpl;
          }
        case 5:
          x++;
          browserTraceImpl.$step = 4;
          browserTraceImpl.$step = 4;
          continue;
        case 0:
          browserTraceImpl.$step = 0;
          browserTraceImpl.value = p;
          browserTraceImpl.done = true;
          return browserTraceImpl;
        case 1:
          browserTraceImpl.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
function traceAllImpl(prefix, s) {
  return [...(prefix[0] === "!" ? traceImpl(prefix, s) : verify(traceImpl(prefix, s)))];
}
function traceArgs(impl) {
  return function traceImpl(prefix, s) {
    if (prefix == null || prefix.substr == null) {
      if (s == null) s = prefix;
      prefix = "";
    }
    if (prefix.length) prefix += ":";
    if (s == null) return s => impl(prefix, s);
    return impl(prefix, s);
  };
}
function cleanComments(s) {
  var i,
    cleanComments = M.generator(),
    loop,
    r,
    p;
  cleanComments.step = cleanComments_1;
  cleanComments.$step = 3;
  return cleanComments;
  function cleanComments_1(p) {
    for (;;) {
      switch (cleanComments.$cur = cleanComments.$step) {
        case 3:
          loop = M.iterator(s);
          cleanComments.$step = 4;
          cleanComments.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.enter) {
              i.comments = null;
              i.tcomments = null;
              if (i.node) {
                i.node.leadingComments = null;
                i.node.trailingComments = null;
              }
            }
            cleanComments.$step = 4;
            cleanComments.value = i;
            return cleanComments;
          } else {
            cleanComments.$step = 0;
            cleanComments.value = void 0;
            cleanComments.done = true;
            return cleanComments;
          }
        case 0:
          cleanComments.$step = 0;
          cleanComments.value = p;
          cleanComments.done = true;
          return cleanComments;
        case 1:
          cleanComments.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
const traceLazy = exports.traceLazy = traceArgs(traceImpl);
const traceAll = exports.traceAll = traceArgs(traceAllImpl);
const traceDoc = exports.traceDoc = traceArgs(traceDocImpl);
function markNodeType(s) {
  var i,
    ti,
    markNodeType = M.generator(),
    loop,
    r,
    p;
  markNodeType.step = markNodeType_1;
  markNodeType.$step = 3;
  return markNodeType;
  function markNodeType_1(p) {
    for (;;) {
      switch (markNodeType.$cur = markNodeType.$step) {
        case 3:
          loop = M.iterator(s);
          markNodeType.$step = 4;
          markNodeType.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            ti = (0, _types2.typeInfo)(i);
            if (ti.kind === "ctrl") {
              (i.comments || (i.comments = [])).unshift({
                txt: (0, _types2.symName)(i.type),
                style: styles.nodetype
              });
            } else {
              if (i.comments != null && i.comments.length) {
                (i.comments || (i.comments = [])).unshift({
                  txt: (0, _types2.symName)(i.type).match(/[A-Z]/g).join(""),
                  style: styles.nodetype
                });
              }
            }
            markNodeType.$step = 4;
            markNodeType.value = i;
            return markNodeType;
          } else {
            markNodeType.$step = 0;
            markNodeType.value = void 0;
            markNodeType.done = true;
            return markNodeType;
          }
        case 0:
          markNodeType.$step = 0;
          markNodeType.value = p;
          markNodeType.done = true;
          return markNodeType;
        case 1:
          markNodeType.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
const color = exports.color = _config.default.browserDebug ? function color(s) {
  var i,
    j,
    _j,
    _color = M.generator(),
    loop,
    _loop,
    loop1,
    r,
    p;
  _color.step = color_1;
  _color.$step = 3;
  return _color;
  function color_1(p) {
    var a;
    for (;;) {
      switch (_color.$cur = _color.$step) {
        case 3:
          if (!_config.default.color) {
            _color.$step = 5;
            return _color.$delegate(s);
          } else {
            loop = M.iterator((0, _core.hier)(s));
            _color.$step = 4;
            _color.$step = 4;
            continue;
          }
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.start && i.value.comments) {
              _loop = M.iterator(i.value.comments);
              for (; !(_loop = _loop.step()).done;) {
                j = _loop.value;
                if (j.style != null && (0, _types2.typeInfo)(i).kind === "node") {
                  j.txt = `%c${j.txt}%c`;
                  j.args = [j.style, ""];
                }
              }
            }
            if (!i.start && i.value.tcomments) {
              loop1 = M.iterator(i.value.tcomments);
              for (; !(loop1 = loop1.step()).done;) {
                _j = loop1.value;
                if (_j.style != null && (0, _types2.typeInfo)(i).kind === "node") {
                  _j.txt = `%c${_j.txt}%c`;
                  _j.args = [_j.style, ""];
                }
              }
            }
            if (i.start) {
              a = i.value;
              _color.$step = 4;
              _color.value = a;
              return _color;
            } else {
              _color.$step = 4;
              _color.$step = 4;
              continue;
            }
          } else {
            _color.$step = 0;
            _color.value = void 0;
            _color.done = true;
            return _color;
          }
        case 0:
          _color.$step = 0;
          _color.value = p;
          _color.done = true;
          return _color;
        case 1:
          _color.$step = 0;
          throw p;
        case 5:
          _color.$step = 0;
          _color.$step = 0;
          p = r;
          continue;
        case 2:
          return _color.$redir(p);
        default:
          throw new Error("invalid state");
      }
    }
  }
} : s => s;
function getArgs(s) {
  var i,
    j,
    k,
    _j,
    _k,
    getArgs = M.generator(),
    loop,
    _loop,
    loop1,
    loop2,
    loop3,
    r,
    p;
  getArgs.step = getArgs_1;
  getArgs.$step = 3;
  return getArgs;
  function getArgs_1(p) {
    for (;;) {
      switch (getArgs.$cur = getArgs.$step) {
        case 3:
          loop = M.iterator((0, _core.hier)(s));
          getArgs.$step = 4;
          getArgs.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.start && i.value.comments) {
              _loop = M.iterator(i.value.comments);
              getArgs.$step = 5;
              getArgs.$step = 5;
              continue;
            } else {
              getArgs.$step = 7;
              getArgs.$step = 7;
              continue;
            }
          } else {
            getArgs.$step = 0;
            getArgs.value = void 0;
            getArgs.done = true;
            return getArgs;
          }
        case 5:
          if (!(_loop = _loop.step()).done) {
            j = _loop.value;
            if (j.args) {
              loop1 = M.iterator(j.args);
              getArgs.$step = 6;
              getArgs.$step = 6;
              continue;
            } else {
              getArgs.$step = 5;
              getArgs.$step = 5;
              continue;
            }
          } else {
            getArgs.$step = 7;
            getArgs.$step = 7;
            continue;
          }
        case 6:
          if (!(loop1 = loop1.step()).done) {
            k = loop1.value;
            getArgs.$step = 6;
            getArgs.value = k;
            return getArgs;
          } else {
            getArgs.$step = 5;
            getArgs.$step = 5;
            continue;
          }
        case 7:
          if (!i.start && i.value.tcomments) {
            loop2 = M.iterator(i.value.tcomments);
            getArgs.$step = 8;
            getArgs.$step = 8;
            continue;
          } else {
            getArgs.$step = 4;
            getArgs.$step = 4;
            continue;
          }
        case 8:
          if (!(loop2 = loop2.step()).done) {
            _j = loop2.value;
            if (_j.args) {
              loop3 = M.iterator(_j.args);
              getArgs.$step = 9;
              getArgs.$step = 9;
              continue;
            } else {
              getArgs.$step = 8;
              getArgs.$step = 8;
              continue;
            }
          } else {
            getArgs.$step = 4;
            getArgs.$step = 4;
            continue;
          }
        case 9:
          if (!(loop3 = loop3.step()).done) {
            _k = loop3.value;
            getArgs.$step = 9;
            getArgs.value = _k;
            return getArgs;
          } else {
            getArgs.$step = 8;
            getArgs.$step = 8;
            continue;
          }
        case 0:
          getArgs.$step = 0;
          getArgs.value = p;
          getArgs.done = true;
          return getArgs;
        case 1:
          getArgs.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
function applyComments(s) {
  var i,
    node,
    applyComments = M.generator(),
    loop,
    r,
    p;
  applyComments.step = applyComments_1;
  applyComments.$step = 3;
  return applyComments;
  function applyComments_1(p) {
    var a;
    for (;;) {
      switch (applyComments.$cur = applyComments.$step) {
        case 3:
          loop = M.iterator((0, _core.hier)(s));
          applyComments.$step = 4;
          applyComments.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            node = i.value.node;
            if (i.start && node != null) {
              if (i.value.comments != null && i.value.comments.length) {
                (node.leadingComments || (node.leadingComments = [])).push({
                  type: "CommentBlock",
                  value: i.value.comments.map(v => v.txt).join("|")
                });
              }
              if (!i.start && i.value.tcomments != null && i.value.tcomments.length) {
                (node.trailingComments || (node.trailingComments = [])).push({
                  type: "CommentBlock",
                  value: i.value.tcomments.map(v => v.txt).join("|")
                });
              }
            }
            if (i.start) {
              a = i.value;
              applyComments.$step = 4;
              applyComments.value = a;
              return applyComments;
            } else {
              applyComments.$step = 4;
              applyComments.$step = 4;
              continue;
            }
          } else {
            applyComments.$step = 0;
            applyComments.value = void 0;
            applyComments.done = true;
            return applyComments;
          }
        case 0:
          applyComments.$step = 0;
          applyComments.value = p;
          applyComments.done = true;
          return applyComments;
        case 1:
          applyComments.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
const dumpToConsole = exports.dumpToConsole = (0, _combinators.curry)(function toConsole(tag, s) {
  var root, name, col, args;
  s = (0, _core.lookahead)(s);
  root = s.buf;
  name = (0, _types2.symName)(root.type).match(/[A-Z]/g).join("");
  if (root.funcId) name += ":" + root.funcId.id;
  if (_config.default.browserDebug) (tag[0] === "+" ? console.group : console.groupCollapsed)(`dump %c${tag} %c${name}`, "color:orange;font-size:large", "color:coral");else console.log(`dump ${tag}`);
  col = (0, _combinators.pipe)(color, tempNames, _core.toArray, applyComments, _core.toArray)(s);
  args = Array.from(getArgs(col));
  (0, _core.consume)((0, _core.fromIterable)(verify(col)));
  console.log((0, _generator.default)(col[0].node).code, ...args);
  if (_config.default.browserDebug) console.groupEnd();
});
const dumpDoc = exports.dumpDoc = (0, _combinators.curry)(function (tag, root) {
  dumpToConsole(tag, (0, _core.dft)(root));
  return root;
});
const fin = exports.fin = (0, _combinators.pipe)(tempNames, applyComments, _core.toArray);
function dumpToStr(s, opts = {}) {
  return (0, _generator.default)((0, _core.consume)(s), opts).code;
}
function setComment(i, txt, style = "none") {
  style = style.substr && styles[style] || style;
  (i.comments || (i.comments = [])).push({
    txt,
    style
  });
  return i;
}
function setEndComment(i, txt, style = "none") {
  style = style.substr && styles[style] || style;
  (i.tcomments || (i.tcomments = [])).push({
    txt,
    style
  });
  return i;
}
function copyComment(f, t) {
  if (f.comments != null) (t.comments || (t.comments = [])).push(...f.comments);
  if (f.tcomments != null) (t.tcomments || (t.tcomments = [])).push(...f.tcomments);
  return t;
}
const styles = {
  large: "font-size:xx-large;color:orange",
  hl: "font-size:large;color:navy;",
  small: "font-size:large;color:navy;",
  smallH: "font-size:large;color:orange;font-weight:bolder",
  nodetype: "font-size:xx-small;color:green;font-weight:bolder",
  none: ""
};

/**
 * sets temporal `node.name` for each Identifier for debug dumps outputs
 */
function tempNames(s) {
  var i,
    tempNames = M.generator(),
    loop,
    r,
    p;
  tempNames.step = tempNames_1;
  tempNames.$step = 3;
  return tempNames;
  function tempNames_1(p) {
    for (;;) {
      switch (tempNames.$cur = tempNames.$step) {
        case 3:
          loop = M.iterator(s);
          tempNames.$step = 4;
          tempNames.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (i.type === _types2.Tag.Identifier && i.sym != null && (!i.node.name || i.node.name !== i.sym.orig)) {
              i.node.name = i.sym.strict ? i.sym.name : i.sym.id;
            }
            tempNames.$step = 4;
            tempNames.value = i;
            return tempNames;
          } else {
            tempNames.$step = 0;
            tempNames.value = void 0;
            tempNames.done = true;
            return tempNames;
          }
        case 0:
          tempNames.$step = 0;
          tempNames.value = p;
          tempNames.done = true;
          return tempNames;
        case 1:
          tempNames.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
}
function tempNamesRange(from, to) {
  var i;
  var loop = M.iterator((0, _core.dft)(from, to));
  for (; !(loop = loop.step()).done;) {
    i = loop.value;
    if (i.type === _types2.Tag.Identifier && i.sym != null && (!i.node.name || i.node.name !== i.sym.orig)) i.node.name = i.sym.strict ? i.sym.name : i.sym.id;
  }
}