dt-stream/dt-stream.browser.js

Δt stream adapter - async & dynamic templating engine

;(function(){var require = function (file, cwd) {
    var resolved = require.resolve(file, cwd || '/');
    var mod = require.modules[resolved];
    if (!mod) throw new Error(
        'Failed to resolve module ' + file + ', tried ' + resolved
    );
    var res = mod._cached ? mod._cached : mod();
    return res;
}
var __require = require;

require.paths = [];
require.modules = {};
require.extensions = [".js",".coffee"];

require._core = {
    'assert': true,
    'events': true,
    'fs': true,
    'path': true,
    'vm': true
};

require.resolve = (function () {
    return function (x, cwd) {
        if (!cwd) cwd = '/';
        
        if (require._core[x]) return x;
        var path = require.modules.path();
        var y = cwd || '.';
        
        if (x.match(/^(?:\.\.?\/|\/)/)) {
            var m = loadAsFileSync(path.resolve(y, x))
                || loadAsDirectorySync(path.resolve(y, x));
            if (m) return m;
        }
        
        var n = loadNodeModulesSync(x, y);
        if (n) return n;
        
        throw new Error("Cannot find module '" + x + "'");
        
        function loadAsFileSync (x) {
            if (require.modules[x]) {
                return x;
            }
            
            for (var i = 0; i < require.extensions.length; i++) {
                var ext = require.extensions[i];
                if (require.modules[x + ext]) return x + ext;
            }
        }
        
        function loadAsDirectorySync (x) {
            x = x.replace(/\/+$/, '');
            var pkgfile = x + '/package.json';
            if (require.modules[pkgfile]) {
                var pkg = require.modules[pkgfile]();
                var b = pkg.browserify;
                if (typeof b === 'object' && b.main) {
                    var m = loadAsFileSync(path.resolve(x, b.main));
                    if (m) return m;
                }
                else if (typeof b === 'string') {
                    var m = loadAsFileSync(path.resolve(x, b));
                    if (m) return m;
                }
                else if (pkg.main) {
                    var m = loadAsFileSync(path.resolve(x, pkg.main));
                    if (m) return m;
                }
            }
            
            return loadAsFileSync(x + '/index');
        }
        
        function loadNodeModulesSync (x, start) {
            var dirs = nodeModulesPathsSync(start);
            for (var i = 0; i < dirs.length; i++) {
                var dir = dirs[i];
                var m = loadAsFileSync(dir + '/' + x);
                if (m) return m;
                var n = loadAsDirectorySync(dir + '/' + x);
                if (n) return n;
            }
            
            var m = loadAsFileSync(x);
            if (m) return m;
        }
        
        function nodeModulesPathsSync (start) {
            var parts;
            if (start === '/') parts = [ '' ];
            else parts = path.normalize(start).split('/');
            
            var dirs = [];
            for (var i = parts.length - 1; i >= 0; i--) {
                if (parts[i] === 'node_modules') continue;
                var dir = parts.slice(0, i + 1).join('/') + '/node_modules';
                dirs.push(dir);
            }
            
            return dirs;
        }
    };
})();

require.alias = function (from, to) {
    var path = require.modules.path();
    var res = null;
    try {
        res = require.resolve(from + '/package.json', '/');
    }
    catch (err) {
        res = require.resolve(from, '/');
    }
    var basedir = path.dirname(res);
    
    var keys = Object_keys(require.modules);
    
    for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        if (key.slice(0, basedir.length + 1) === basedir + '/') {
            var f = key.slice(basedir.length);
            require.modules[to + f] = require.modules[basedir + f];
        }
        else if (key === basedir) {
            require.modules[to] = require.modules[basedir];
        }
    }
};

require.define = function (filename, fn) {
    var dirname = require._core[filename]
        ? ''
        : require.modules.path().dirname(filename)
    ;
    
    var require_ = function (file) { return require(file, dirname) };
    require_.resolve = function (name) {
      return require.resolve(name, dirname);
    };
    require_.modules = require.modules;
    var module_ = { exports : {} };
    
    require.modules[filename] = function () {
        fn.call(
            module_.exports,
            require_,
            module_,
            module_.exports,
            dirname,
            filename
        );
        require.modules[filename]._cached = module_.exports;
        return module_.exports;
    };
};

var Object_keys = Object.keys || function (obj) {
    var res = [];
    for (var key in obj) res.push(key)
    return res;
};

if (typeof process === 'undefined') process = {};

if (!process.nextTick) process.nextTick = function (fn) {
    setTimeout(fn, 0);
};

if (!process.title) process.title = 'browser';

if (!process.binding) process.binding = function (name) {
    if (name === 'evals') return require('vm')
    else throw new Error('No such module')
};

if (!process.cwd) process.cwd = function () { return '.' };

require.define("path", function (require, module, exports, __dirname, __filename) {
    function filter (xs, fn) {
    var res = [];
    for (var i = 0; i < xs.length; i++) {
        if (fn(xs[i], i, xs)) res.push(xs[i]);
    }
    return res;
}

// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
function normalizeArray(parts, allowAboveRoot) {
  // if the path tries to go above the root, `up` ends up > 0
  var up = 0;
  for (var i = parts.length; i >= 0; i--) {
    var last = parts[i];
    if (last == '.') {
      parts.splice(i, 1);
    } else if (last === '..') {
      parts.splice(i, 1);
      up++;
    } else if (up) {
      parts.splice(i, 1);
      up--;
    }
  }

  // if the path is allowed to go above the root, restore leading ..s
  if (allowAboveRoot) {
    for (; up--; up) {
      parts.unshift('..');
    }
  }

  return parts;
}

// Regex to split a filename into [*, dir, basename, ext]
// posix version
var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;

// path.resolve([from ...], to)
// posix version
exports.resolve = function() {
var resolvedPath = '',
    resolvedAbsolute = false;

for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) {
  var path = (i >= 0)
      ? arguments[i]
      : process.cwd();

  // Skip empty and invalid entries
  if (typeof path !== 'string' || !path) {
    continue;
  }

  resolvedPath = path + '/' + resolvedPath;
  resolvedAbsolute = path.charAt(0) === '/';
}

// At this point the path should be resolved to a full absolute path, but
// handle relative paths to be safe (might happen when process.cwd() fails)

// Normalize the path
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
    return !!p;
  }), !resolvedAbsolute).join('/');

  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
};

// path.normalize(path)
// posix version
exports.normalize = function(path) {
var isAbsolute = path.charAt(0) === '/',
    trailingSlash = path.slice(-1) === '/';

// Normalize the path
path = normalizeArray(filter(path.split('/'), function(p) {
    return !!p;
  }), !isAbsolute).join('/');

  if (!path && !isAbsolute) {
    path = '.';
  }
  if (path && trailingSlash) {
    path += '/';
  }
  
  return (isAbsolute ? '/' : '') + path;
};


// posix version
exports.join = function() {
  var paths = Array.prototype.slice.call(arguments, 0);
  return exports.normalize(filter(paths, function(p, index) {
    return p && typeof p === 'string';
  }).join('/'));
};


exports.dirname = function(path) {
  var dir = splitPathRe.exec(path)[1] || '';
  var isWindows = false;
  if (!dir) {
    // No dirname
    return '.';
  } else if (dir.length === 1 ||
      (isWindows && dir.length <= 3 && dir.charAt(1) === ':')) {
    // It is just a slash or a drive letter with a slash
    return dir;
  } else {
    // It is a full dirname, strip trailing slash
    return dir.substring(0, dir.length - 1);
  }
};


exports.basename = function(path, ext) {
  var f = splitPathRe.exec(path)[2] || '';
  // TODO: make this comparison case-insensitive on windows?
  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }
  return f;
};


exports.extname = function(path) {
  return splitPathRe.exec(path)[3] || '';
};

});

require.define("/dt-stream.js", function (require, module, exports, __dirname, __filename) {
    (function() {
  var EVENTS, Entry, OrderedEmitter, Stream, StreamAdapter, attrStr, prettify, streamify, _ref,
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

  Stream = require('stream').Stream;

  OrderedEmitter = require('ordered-emitter');

  _ref = require('./util'), prettify = _ref.prettify, attrStr = _ref.attrStr;

  EVENTS = ['add', 'close', 'end', 'remove', 'attr', 'text', 'raw', 'data'];

  Entry = (function() {
    function Entry(stream, el, parent) {
      var idx, _ref1, _ref2, _ref3, _ref4, _ref5,
        _this = this;

      this.stream = stream;
      this.parent = parent;
      this["delete"] = __bind(this["delete"], this);
      this.release = __bind(this.release, this);
      this.do_job = __bind(this.do_job, this);
      this.order = new OrderedEmitter({
        span: true
      });
      this.released = false;
      this.isnext = this.parent != null ? false : true;
      this.children = 0;
      this.order.on('entry', this.do_job);
      if (this.isnext) {
        return;
      }
      if ((_ref1 = this.parent) != null) {
        _ref1._stream.write(function() {
          if (!el.isempty || el.closed === true) {
            _this.release();
          }
          return _this.isnext = true;
        });
      }
      idx = (_ref2 = (_ref3 = this.parent) != null ? _ref3._stream.children : void 0) != null ? _ref2 : -1;
      if ((_ref4 = this.parent) != null) {
        _ref4._stream.children++;
      }
      el.ready(function() {
        var _ref5;

        return (_ref5 = this.parent) != null ? _ref5._stream.emit('close scope', {
          order: idx + 1
        }) : void 0;
      });
      if ((_ref5 = this.parent) != null) {
        _ref5._stream.release();
      }
    }

    Entry.prototype.do_job = function(_arg) {
      var job;

      job = _arg.job;
      if (!job) {
        return;
      }
      if (this.stream.paused) {
        return this.stream.queue.push(job);
      } else {
        return job();
      }
    };

    Entry.prototype.emit = function() {
      var _ref1;

      return (_ref1 = this.order) != null ? _ref1.emit.apply(_ref1, arguments) : void 0;
    };

    Entry.prototype.write = function(job) {
      var payload;

      payload = {
        job: job,
        order: ++this.children
      };
      if (this.stream.paused) {
        if (this.children > 1 && this.isnext) {
          this.stream.queue.push(this.release);
        }
        return this.stream.queue.push(this.emit.bind(this, 'entry', payload));
      } else {
        if (this.children > 1 && this.isnext) {
          this.release();
        }
        return this.emit('entry', payload);
      }
    };

    Entry.prototype.release = function() {
      if (this.released) {
        return;
      }
      this.emit('open scope', {
        order: 0
      });
      return this.released = true;
    };

    Entry.prototype["delete"] = function() {
      this.order.removeAllListeners();
      this.order.reset();
      this.order.clear();
      delete this.parent;
      return delete this.order;
    };

    return Entry;

  })();

  StreamAdapter = (function(_super) {
    __extends(StreamAdapter, _super);

    function StreamAdapter(template, opts) {
      var _base, _ref1, _ref2, _ref3, _ref4;

      this.template = template;
      if (opts == null) {
        opts = {};
      }
      this.close = __bind(this.close, this);
      StreamAdapter.__super__.constructor.call(this);
      this.builder = (_ref1 = this.template.xml) != null ? _ref1 : this.template;
      if ((_ref2 = (_base = this.builder).apdaters) == null) {
        _base.apdaters = {};
      }
      this.builder.apdaters['stream'] = this;
      this.autoremove = (_ref3 = opts.autoremove) != null ? _ref3 : true;
      this.setEncoding((_ref4 = opts.encoding) != null ? _ref4 : 'utf8');
      this.opened_tags = 0;
      this.readable = true;
      this.paused = false;
      this.queue = [];
      if (opts.stream) {
        this.pipe(opts.stream);
      }
      this.initialize();
    }

    StreamAdapter.prototype.initialize = function() {
      this.template.stream = this;
      this.builder._stream = new Entry(this, this.builder);
      this.listen();
      return this.template.register('ready', this.approve_ready);
    };

    StreamAdapter.prototype.approve_ready = function(tag, next) {
      if (tag._stream_ready === true) {
        return next(tag);
      } else {
        return tag._stream_ready = function() {
          return next(tag);
        };
      }
    };

    StreamAdapter.prototype.listen = function() {
      var _this = this;

      return EVENTS.forEach(function(event) {
        return _this.template.on(event, _this["on" + event].bind(_this));
      });
    };

    StreamAdapter.prototype.write = function(data) {
      if (!data) {
        return;
      }
      if (this.paused) {
        this.emit('error', "write data while paused");
      }
      return this.emit('data', data);
    };

    StreamAdapter.prototype.close = function() {
      this.builder.closed = true;
      this.readable = false;
      this.emit('end');
      return this.emit('close');
    };

    StreamAdapter.prototype.setEncoding = function(encoding) {
      this.encoding = encoding;
    };

    StreamAdapter.prototype.pause = function() {
      if (this.paused) {
        return;
      }
      this.paused = true;
      this.emit('pause');
      return this.template.emit('pause');
    };

    StreamAdapter.prototype.resume = function() {
      var _base;

      if (this.paused) {
        this.emit('resume');
        this.template.emit('resume');
        this.paused = false;
      }
      while (!this.paused && this.queue.length) {
        if (typeof (_base = this.queue.shift()) === "function") {
          _base();
        }
      }
      if ((this.closed != null) && !this.queue.length) {
        if (typeof this.closed === "function") {
          this.closed();
        }
        this.closed = true;
      }
    };

    StreamAdapter.prototype.onadd = function(parent, el) {
      var _this = this;

      if (!parent.writable) {
        console.warn("creating " + (el.toString()) + " in closed " + (parent.toString()) + " omitted");
        return;
      }
      el._stream = new Entry(this, el, parent);
      this.opened_tags++;
      el._stream.write(function() {
        if (el === el.builder) {
          return;
        }
        if (el.isempty && el.closed === true) {
          return _this.write(prettify(el, "<" + el.name + (attrStr(el.attrs)) + "/>"));
        } else {
          return _this.write(prettify(el, "<" + el.name + (attrStr(el.attrs)) + ">"));
        }
      });
      if (!this.autoremove) {
        return;
      }
      return el.ready(function() {
        if (el.closed === 'removed') {
          return _this.onremove(el);
        } else {
          return el.remove();
        }
      });
    };

    StreamAdapter.prototype.onremove = function(el) {
      if (el._stream == null) {
        return;
      }
      this.opened_tags--;
      if (this.opened_tags === 0 && this.builder.closed === 'pending' && !this.queue.length) {
        if (typeof this.closed === "function") {
          this.closed();
        }
        this.closed = true;
      }
      return el._stream.write(function() {
        el._stream["delete"]();
        return delete el._stream;
      });
    };

    StreamAdapter.prototype.onclose = function(el) {
      var _ref1,
        _this = this;

      return (_ref1 = el._stream) != null ? _ref1.write(function() {
        if (!(el.isempty || el === el.builder)) {
          _this.write(prettify(el, "</" + el.name + ">"));
        }
        if (typeof el._stream_ready === "function") {
          el._stream_ready();
        }
        return el._stream_ready = true;
      }) : void 0;
    };

    StreamAdapter.prototype.ondata = function(el, data) {
      var _ref1,
        _this = this;

      return (_ref1 = el._stream) != null ? _ref1.write(function() {
        return _this.write(data);
      }) : void 0;
    };

    StreamAdapter.prototype.ontext = function(el, text) {
      var _ref1,
        _this = this;

      return (_ref1 = el._stream) != null ? _ref1.write(function() {
        return _this.write(prettify(el, text));
      }) : void 0;
    };

    StreamAdapter.prototype.onraw = function(el, html) {
      var _ref1,
        _this = this;

      return (_ref1 = el._stream) != null ? _ref1.write(function() {
        return _this.write(html);
      }) : void 0;
    };

    StreamAdapter.prototype.onattr = function(el, key, value) {
      if (!el.isempty) {
        return;
      }
      if (el._stream_ready !== true) {
        return;
      }
      return console.warn("attributes of " + (el.toString()) + " don't change anymore");
    };

    StreamAdapter.prototype.onend = function() {
      if ((this.closed != null) || this.opened_tags === 0) {
        return this.close();
      }
      this.builder.closed = 'pending';
      return this.closed = this.close;
    };

    return StreamAdapter;

  })(Stream);

  streamify = function(tpl, opts) {
    new StreamAdapter(tpl, opts);
    return tpl;
  };

  streamify.Adapter = StreamAdapter;

  module.exports = streamify;

  if (process.title === 'browser') {
    (function() {
      if (this.dynamictemplate != null) {
        return this.dynamictemplate.streamify = streamify;
      } else {
        return this.dynamictemplate = {
          streamify: streamify
        };
      }
    }).call(window);
  }

}).call(this);

});

require.define("stream", function (require, module, exports, __dirname, __filename) {
    // todo

});

require.define("/node_modules/ordered-emitter/package.json", function (require, module, exports, __dirname, __filename) {
    module.exports = {"name":"ordered-emitter","version":"0.1.1","description":"emit events in order","main":"index.js","directories":{"lib":".","example":"example","test":"test"},"devDependencies":{"tap":"~0.4.3"},"scripts":{"test":"tap test"},"repository":{"type":"git","url":"http://github.com/substack/node-ordered-emitter.git"},"keywords":["ordered","buffer","event","emitter"],"author":{"name":"James Halliday","email":"mail@substack.net","url":"http://substack.net"},"license":"MIT/X11","engine":{"node":">=0.4"}}
});

require.define("/node_modules/ordered-emitter/index.js", function (require, module, exports, __dirname, __filename) {
    var EventEmitter = require('events').EventEmitter;
var inherits = require('util').inherits;

module.exports = OrderedEmitter;

function OrderedEmitter (opts) {
    EventEmitter.call(this);
    if (!opts) opts = {};
    
    this._eventQueue = {};
    this._next = {};
    this.options = opts;
}
inherits(OrderedEmitter, EventEmitter);

OrderedEmitter.prototype.reset = function (evName) {
    if (evName === undefined) {
        this._next = {};
    }
    else {
        this._next[evName] = 0;
    }
};

OrderedEmitter.prototype.clear = function (evName) {
    if (evName === undefined) {
        this._eventQueue = {};
    }
    else {
        this._eventQueue[evName] = {};
    }
};

OrderedEmitter.prototype.emit = function (evName, obj) {
    var emit = function (args) {
        EventEmitter.prototype.emit.apply(this, args);
    }.bind(this, arguments);
    
    var queue = this._eventQueue;
    var next = this._next;
    var name = this.options.span ? '*' : evName;
    
    if (typeof obj === 'object' && obj !== null
    && typeof obj.order === 'number') {
        if (!next[name]) next[name] = 0;
        
        if (obj.order === next[name]) {
            next[name] ++;
            emit();
            
            while (queue[name] && queue[name][next[name]]) {
                queue[name][next[name]]();
                delete queue[name][next[name]];
                next[name] ++;
            }
        }
        else {
            if (!queue[name]) queue[name] = {};
            queue[name][obj.order] = emit;
        }
    }
    else emit()
};

});

require.define("events", function (require, module, exports, __dirname, __filename) {
    if (!process.EventEmitter) process.EventEmitter = function () {};

var EventEmitter = exports.EventEmitter = process.EventEmitter;
var isArray = typeof Array.isArray === 'function'
    ? Array.isArray
    : function (xs) {
        return Object.toString.call(xs) === '[object Array]'
    }
;

// By default EventEmitters will print a warning if more than
// 10 listeners are added to it. This is a useful default which
// helps finding memory leaks.
//
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
var defaultMaxListeners = 10;
EventEmitter.prototype.setMaxListeners = function(n) {
  if (!this._events) this._events = {};
  this._events.maxListeners = n;
};


EventEmitter.prototype.emit = function(type) {
  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events || !this._events.error ||
        (isArray(this._events.error) && !this._events.error.length))
    {
      if (arguments[1] instanceof Error) {
        throw arguments[1]; // Unhandled 'error' event
      } else {
        throw new Error("Uncaught, unspecified 'error' event.");
      }
      return false;
    }
  }

  if (!this._events) return false;
  var handler = this._events[type];
  if (!handler) return false;

  if (typeof handler == 'function') {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        var args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
    return true;

  } else if (isArray(handler)) {
    var args = Array.prototype.slice.call(arguments, 1);

    var listeners = handler.slice();
    for (var i = 0, l = listeners.length; i < l; i++) {
      listeners[i].apply(this, args);
    }
    return true;

  } else {
    return false;
  }
};

// EventEmitter is defined in src/node_events.cc
// EventEmitter.prototype.emit() is also defined there.
EventEmitter.prototype.addListener = function(type, listener) {
  if ('function' !== typeof listener) {
    throw new Error('addListener only takes instances of Function');
  }

  if (!this._events) this._events = {};

  // To avoid recursion in the case that type == "newListeners"! Before
  // adding it to the listeners, first emit "newListeners".
  this.emit('newListener', type, listener);

  if (!this._events[type]) {
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  } else if (isArray(this._events[type])) {

    // Check for listener leak
    if (!this._events[type].warned) {
      var m;
      if (this._events.maxListeners !== undefined) {
        m = this._events.maxListeners;
      } else {
        m = defaultMaxListeners;
      }

      if (m && m > 0 && this._events[type].length > m) {
        this._events[type].warned = true;
        console.error('(node) warning: possible EventEmitter memory ' +
                      'leak detected. %d listeners added. ' +
                      'Use emitter.setMaxListeners() to increase limit.',
                      this._events[type].length);
        console.trace();
      }
    }

    // If we've already got an array, just append.
    this._events[type].push(listener);
  } else {
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {
  var self = this;
  self.on(type, function g() {
    self.removeListener(type, g);
    listener.apply(this, arguments);
  });

  return this;
};

EventEmitter.prototype.removeListener = function(type, listener) {
  if ('function' !== typeof listener) {
    throw new Error('removeListener only takes instances of Function');
  }

  // does not use listeners(), so no side effect of creating _events[type]
  if (!this._events || !this._events[type]) return this;

  var list = this._events[type];

  if (isArray(list)) {
    var i = list.indexOf(listener);
    if (i < 0) return this;
    list.splice(i, 1);
    if (list.length == 0)
      delete this._events[type];
  } else if (this._events[type] === listener) {
    delete this._events[type];
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
  // does not use listeners(), so no side effect of creating _events[type]
  if (type && this._events && this._events[type]) this._events[type] = null;
  return this;
};

EventEmitter.prototype.listeners = function(type) {
  if (!this._events) this._events = {};
  if (!this._events[type]) this._events[type] = [];
  if (!isArray(this._events[type])) {
    this._events[type] = [this._events[type]];
  }
  return this._events[type];
};

});

require.define("util", function (require, module, exports, __dirname, __filename) {
    // todo

});

require.define("/util.js", function (require, module, exports, __dirname, __filename) {
    (function() {
  var attrStr, breakline, indent, prettify;

  indent = function(_arg) {
    var level, pretty;

    level = _arg.level, pretty = _arg.pretty;
    if (pretty === true) {
      pretty = "  ";
    }
    return new Array(level + 1).join(pretty);
  };

  breakline = function(_arg, data) {
    var level, pretty;

    level = _arg.level, pretty = _arg.pretty;
    if (!pretty) {
      return data;
    }
    if ((data != null ? data[(data != null ? data.length : void 0) - 1] : void 0) === "\n") {
      return data;
    } else {
      return "" + data + "\n";
    }
  };

  prettify = function(el, data) {
    if (!(el != null ? el.pretty : void 0)) {
      return data;
    } else {
      return "" + (indent(el)) + (breakline(el, data));
    }
  };

  attrStr = function(attrs) {
    var k, strattrs, v;

    if (attrs == null) {
      attrs = {};
    }
    strattrs = (function() {
      var _results;

      _results = [];
      for (k in attrs) {
        v = attrs[k];
        if (v != null) {
          if (!(typeof v === 'number' || typeof v === 'boolean')) {
            v = "\"" + v + "\"";
          }
          _results.push("" + k + "=" + v);
        } else {
          _results.push("" + k);
        }
      }
      return _results;
    })();
    if (strattrs.length) {
      strattrs.unshift('');
    }
    return strattrs.join(' ');
  };

  module.exports = {
    indent: indent,
    breakline: breakline,
    prettify: prettify,
    attrStr: attrStr
  };

}).call(this);

});
;require('./dt-stream');}).call(this);