requirebin sketch

index.js

// powcss demonstration
const powcss=require('powcss');
let pre = document.createElement('pre');
pre.textContent = powcss([]).run(
`
let /**/
  rem=(px) => px/16 +'rem', /*Line-Continuation*/
  spacing=(tracking)=>tracking/12 +'rem',
	cols = [1,2,3,4].join(',.col-')

.col-\${cols}
    display: block
    letter-spacing: \${spacing(-1.5)}

`
).toCSS();

document.body.append(pre);

minified.js

setTimeout(function(){
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],2:[function(require,module,exports){
const IFX = /if[ ]+([_$a-zA-Z]+)[ ]*=/,
  util =  require('./util');

/**
 * PowCSS 缺省的 Compiler 实现.
 * 所有方法采用原生 js 语法, 要求源码自带嵌套占位符 '...'.
 */
class Compiler{

  /**
   * 构造, 参数用来对 this 进行扩展.
   * 缺省 this.ctx = 'ctx' 表示 context 的形参名
   */
  constructor(...extend) {
    extend.forEach((ext) => {
      if (typeof ext === 'function')
        this[ext.name] = ext;
      else if (Object.prototype.toString.call(ext) === '[object Object]') {
        for (let key in ext) {
          this[key] = ext[key];
        }
      }
    });
    this.ctx = this.ctx || 'ctx';
  }

  /**
   * compile 接口
   */
  compile(n, i, ns) {
    return this.decl(n) ||
      this.if(n) ||
      this.each(n) ||
      this.let(n) ||
      this.comment(n) ||
      this.rule(n);
  }

  /**
   * 编译 n.mode === 'comment' 的节点, '/*!' 开头的顶层注释被保留, 其它被抛弃.
   */
  comment(n) {
    if (n.mode !== 'comment') return;
    if (n.column === 1 && n.source[1] === '*' && n.source[2] === '!'){
      let c = JSON.stringify(n.source);
      return `${this.ctx}.open(${c}).close();`;
    }
    return ' ';
  }

  /**
   * 编译 !n.mode 的节点为规则节点
   */
  rule(n) {
    if (n.mode) return;
    let c = n.source.indexOf('${') === -1 && '\'' || '`';
    return n.nodes && n.nodes.length &&
    `${this.ctx}.open(${c}${n.source}${c});
...${this.ctx}.close();` ||
    `${this.ctx}.open(${c}${n.source}${c}).close();`;
  }

  /**
   * 编译 n.mode === 'decl' 的节点
   */
  decl(n) {
    if (n.mode !== 'decl') return;

    let c = n.key.indexOf('${') === -1 && '\'' || '`',
      v = n.val.endsWith(';') ?
        n.val.substring(0, n.val.length - 1) :
        n.val,
      d = v.indexOf('${') === -1 && '\'' || '`';

    return `${this.ctx}.decl(${c}${n.key}${c},${d}${v}${d});`;
  }

  /**
   * if 语句, 原生语法:
   *    if(expr) code;
   *    if (expr) code;
   */
  if(n) {
    if (n.source.startsWith('if(') || n.source.startsWith('if ('))
      return n.source;
  }

  /**
   * each 语句, 原生语法:
   *
   *   each(expr, (val, key)=>{code});
   *   ctx.each(expr, (val, key)=>{code});
   *
   */
  each(n) {
    if (n.source.startsWith(`${this.ctx}.each(`))
      return n.source;
    if (n.source.startsWith('each(')) return this.ctx + '.' + n.source;
  }

  /**
   * let 语句, 原生语法:
   *
   *   let v1 = expr;
   *   let [v1,v2] = [expr, expr]; // ES6 解构赋值
   *   let v1 = expr; code;
   */
  let(n) {
    if (n.source.startsWith('let ')) return n.source;
  }

}

module.exports = function(...extend) {
  return new Compiler(...extend);
};

},{"./util":5}],3:[function(require,module,exports){
/**
 * @typedef {object} Rule   抽象规则
 * @property {string} name  规则名, 也可能是个定义值, 比如 @charset
 * @property {?object<string, string|Rule>} decls 键值声明
 */

/**
 * PowCSS 缺省的 Context 实现.
 * 该实现不分析 CSS 规则的合法性, 只提供结构上的操作和一些辅助方法.
 * 如果要对结果进行再次处理, 推荐使用 walk 方法.
 *
 * @property {Rule}   rule  当前维护的规则, 初始 null
 * @property {Rule[]} rules 最终的规则数组
 * @property {Rule[]} stack 当前规则的 parent 栈
 */
class Context {
  /**
   * 构造, 参数用来对 this 进行扩展.
   */
  constructor(...extend) {
    extend.forEach((ext) => {
      if (typeof ext === 'function')
        this[ext.name] = ext;
      else if (Object.prototype.toString.call(ext) === '[object Object]') {
        for (let key in ext) {
          this[key] = ext[key];
        }
      }
    });
    this.reset();
  }

  /**
   * 重置 .rule, .rules, .stack 为初始状态
   * @return {this}
   */
  reset() {
    this.rule = null;
    this.rules = [];
    this.stack = [];
    return this;
  }
  /**
   * 遍历 x 回调 callback(val, key)
   * @param  {object|array}   x
   * @param  {Function( *, string)} callback 参数顺序 (val, key)
   * @return {this}
   */
  each(x, callback) {
    if (Array.isArray(x)) {
      x.forEach(callback);
    }else
      Object.keys(x).forEach(function(key) {
        callback(x[key], key);
      });
    return this;
  }

  /**
   * 开启一个具名规则并替换 name 中的占位符 '&', 该方法必须与 close 成对使用.
   * 嵌套使用时 this.stack 会增长.
   * @param  {string} name
   * @return {this}
   */
  open(name) {
    if (this.rule) {
      this.stack.push(this.rule);
      if (name.indexOf('&') !== -1)
        name = name.replace(/&/g, this.rule.name);

      if (!this.rule.decls) {
        if (this.rule.name[0] === '@') {
          this.rule.decls = [];
          this.stack.push(this.rules);
          this.rules = this.rule.decls;
        }else if (
          this.rule.name[0] !== '/' &&
          this.rule === this.rules[this.rules.length - 1]
         ) {
          this.rules.pop();
        }
      }
    }
    this.rule = {name};
    this.rules.push(this.rule);
    return this;
  }

  /**
   * 关闭当前的规则, this.stack 会减少, 该方法必须与 .open 成对使用.
   * @return {this}
   */
  close() {
    this.rule = this.stack.pop();
    if (Array.isArray(this.rule)) {
      this.rules = this.rule;
      return this.close();
    }
    return this;
  }

  /**
   * 返回 this.rule.name
   * @return {string}
   */
  name() {
    return this.rule && this.rule.name || '';
  }

  /**
   * 返回或设置当前规则的 key 声明
   * @param  {string}  key
   * @param  {?string} val
   * @return {string}
   */
  decl(key, val) {
    if (val) {
      if (!this.rule.decls)
        this.rule.decls = {};
      this.rule.decls[key] = val;
      return val;
    }
    return this.rule.decls[key] || '';
  }

  /**
   * 输出 this.rules 为 CSS 源码
   * @return {string} css
   */
  toCSS() {
    let toCSS = (css, rule)=> {
      if (rule.decls) {
        css += rule.name + ' {\n';
        if (Array.isArray(rule.decls)) {
          css += rule.decls.reduce(toCSS, '');
        }else for (let key in rule.decls) {
          if (typeof rule.decls[key] === 'string')
            css += key + ': ' + rule.decls[key] + ';\n';
          else
            throw new Error('decls must be a string or array: ' + rule.name + '{' + key + '}');
        }
        css += '}\n';
      }else if (rule.name[0] === '/') // comment
        css += rule.name + '\n';
      else if (rule.name[0] === '@') // 有些规则只是为了嵌套 '&', 没有 decls
        css += rule.name + ';\n';
      else
        throw new Error('Unexpected bare rule: ' + rule.name);
      return css;
    };

    return this.rules.reduce(toCSS, '');
  }

  /**
   * 遍历 this.rules 调用 context 的 open, close, decl 方法.
   * context 的 open, close 返回的对象会用于后续的迭代.
   * 任何一个方法返回非真值会终止遍历.
   * @param  {object}  context  实现 open, close, decl 方法的对象
   * @return {boolean} finished 是否完全遍历
   */
  walk(context) {
    let walk = function(rule) {
      let self = this;
      if (rule.decls) {
        self = self.open(rule.name);
        if (Array.isArray(rule.decls)) {
          if (!rule.decls.every(walk, self))
            return false;
        }else for (let key in rule.decls) {
          if (typeof rule.decls[key] === 'string') {
            if (!self.decl(key, rule.decls[key])) return false;
          }else {
            throw new Error('decls must be a string or array: ' + rule.name + '{' + key + '}');
          }
        }
      }else if (rule.name[0] === '/' || rule.name[0] === '@') {
        self = self.open(rule.name);
      }else {
        throw new Error('Unexpected bare rule: ' + rule.name);
      }
      if (self) self = self.close();
      return !!self;
    };
    return this.rules.every(walk, context);
  }
}

module.exports = function(...extend) {
  return new Context(...extend);
};

},{}],4:[function(require,module,exports){
/**
 * lineify 是个非空白行扫描器, 扫描并返回非空白行信息.
 * @param {string} source 待扫描的字符串
 */
class lineify{
  constructor(source) {
    this.crlf = source.indexOf('\r\n') != -1 && '\r\n' ||
      source.indexOf('\r') != -1 && '\r' || '\n';
    this.crlfLength = this.crlf.length;

    this.bol = 0;
    this.eol = 0;
    this.column = 1;
    this.line = 1;
    this.source = source;
    this.scan(null);
  }

  /**
   * 返回扫描到的非空白行字符串和位置信息, 并前进. 结构:
   *   {source, offset, line, column}
   * @return {Object|null} token 返回 null 表示 EOF
   */
  scan() {
    let tok = {
      source: this.source.substring(this.bol, this.eol).trimRight(),
      offset: this.bol,
      line: this.line,
      column: this.column
    };

    if (this.eol === this.source.length) {
      this.bol = this.eol;
      return tok.source && tok || null;
    }

    if (this.eol) {
      this.bol = this.eol + this.crlfLength;
      this.line++;
      this.column = 1;
    }

    this.eol = this.source.indexOf(this.crlf, this.bol);

    if (this.eol === -1)
      this.eol = this.source.length;

    while (1) {
      let c = this.source.charCodeAt(this.bol);
      if (c === 32 || c === 9) {
        this.bol++;
        this.column++;
        continue;
      }

      if (this.eol !== this.bol) break;
      if (this.eol === this.source.length) break;

      this.line++;
      this.column = 1;

      this.bol = this.eol + this.crlfLength;
      this.eol = this.source.indexOf(this.crlf, this.bol);

      if (this.eol === -1)
        this.eol = this.source.length;
    }

    return tok;
  }
}

module.exports = function(source) {
  return new lineify(source);
};

},{}],5:[function(require,module,exports){
const toString = Object.prototype.toString;

/**
 * 辅助方法集合
 */
let util = {
  /**
   * 返回包含位置信息的字符串, 常用于出错信息
   * @param  {string}  message 自定义信息
   * @param  {object}  loc     含有 line, column 的位置信息
   * @param  {?string} at      缺省为 <anonymous>
   * @return {string}
   */
  info: function(message, loc, at) {
    return `${message} at: ${at || '<anonymous>'}:${loc.line}:${loc.column}`;
  },
  /**
   * isObject
   * @param  {*} x
   * @return {Boolean}
   */
  isObject: function(x) {
    return toString.call(x) === '[object Object]';
  },
  /**
   * isNumber
   * @param  {*} x
   * @return {Boolean}
   */
  isNumber: function(x) {
    return toString.call(x) === '[object Number]';
  },
  /**
   * isArray
   * @param  {*} x
   * @return {Boolean}
   */
  isArray: function(x) {
    return Array.isArray(x);
  },
  /**
   * isString
   * @param  {*} x
   * @return {Boolean}
   */
  isString: function(x) {
    return typeof x === 'string';
  },
  /**
   * isFunction
   * @param  {*} x
   * @return {Boolean}
   */
  isFunction: function(x) {
    return typeof x === 'function';
  }
};

module.exports = util;

},{}],"powcss":[function(require,module,exports){
(function (process){
const lineify = require('./lineify'),
  compiler = require('./compiler'),
  context = require('./context'),
  util =  require('./util'),
  CONTINUATION = '&\\,+-/*|=([';

/**
 * PowCSS 负责解析 source 为节点树, 并拼接编译器的编译结果.
 * 在 PowCSS 中的插件就是 compiler, compiler 负责与 context 配合.
 */
class PowCSS {
  /**
   * @param  {?Compiler[]} plugins 编译器数组, 缺省为 [compiler()]
   */
  constructor(plugins) {
    this.plugins = plugins && plugins.length && plugins || [compiler()];
  }

  /**
   * 使用一个编译器插件
   * @param  {Compiler} plugin
   * @return {this}
   */
  use(plugin) {
    if (plugin)
      this.plugins.push(plugin);
    return this;
  }

  /**
   * 包装 this.result = this.parse(source) 并返回 this.
   * @param  {string}  source  源码
   * @return {this}
   */
  process(source) {
    this.result = source;
    if (!source) return this;
    this.result = this.parse(source);
    return this;
  }

  /**
   * 解析 source 为节点树.
   * 节点类型:
   *   1. root    {mode:'root', nodes}
   *   1. comment {mode:'comment', source} 只保留非行尾注释
   *   1. decl    {mode:'decl', source, key, val}
   *   1. pending {mode:'', source, nodes}
   *
   * 即所有 !mode 的节点需要通过编译插件进行确认
   * @param  {string} source 源码
   * @return {object} root 节点树
   */
  parse(source) {
    if (typeof source !== 'string') return source;

    let root = {
          offset: 0,
          line: 0,
          column: 0,
          mode: 'root',
          nodes: []
        },
        parent = root,
        stack = [],
        i = 0,
        tokens = [],
        lines = lineify(source),
        tok = lines.scan(),
        algin = tok && tok.column || 1;

    while (tok) {
      tokens.push(tok);
      tok = lines.scan();
    }

    while (i < tokens.length) {
      tok = tokens[i];

      while (tok.column <= parent.column) {
        parent = stack.pop();
        algin = parent.nodes[parent.nodes.length - 1].column;
      }

      // 传统花括号块格式
      if (tok.source[0] === '}') {
        let last = parent.nodes[parent.nodes.length - 1];
        if (!last.source.endsWith('{'))
          throw new Error(util.info(`Unpaired brackets from ${last.line}:${last.column}` , tok));
        last.source = last.source.slice(0, -1).trimRight();
        i++;
        continue;
      }

      if (tok.column > algin) {
        algin = tok.column;
        tok.nodes = tok.nodes || [];
        stack.push(parent);
        if (!parent.nodes.length)
          throw new Error(util.info('PowCSS broken', tok));
        parent = parent.nodes[parent.nodes.length - 1];
        continue;
      }
      i++;
      parent.nodes.push(tok);

      if (tok.source.startsWith('//')) {
        tok.mode = 'comment';
        continue;
      }

      if (tok.source.startsWith('/*')) {
        if (tok.source.endsWith('*/'))
          tok.mode = 'comment';
        else while (i < tokens.length) {
          tok.source += '\n' + tokens[i++].source;
          if (tok.source.endsWith('*/')) {
            tok.mode = 'comment';
            break;
          }
        }
        if (tok.mode !== 'comment')
          throw new Error(util.info('Unclosed comments', tok));
        continue;
      }

      let tail = tok.source.indexOf(' //');

      /**
       * 行尾注释必须以 ' //' 开头
       */
      if (tail !== -1)
        tok.source = tok.source.substring(0, tail).trim();

      /**
       * 属性名和值不能以 '@' 开头
       * 属性分隔符 ':' 之后必须是空格或者换行 `:[ \n]`
       */
      let pos = tok.source[0] === '@' && -1 || tok.source.indexOf(':') + 1;
      tok.mode = pos > 0 &&
        (pos === tok.source.length || tok.source[pos] === ' ') &&
        'decl' || '';

      tok.nodes = [];

      /**
       * 续行符包括 `\\,+-/*|=([`
       */
      tail = CONTINUATION.indexOf(tok.source.charAt(tok.source.length - 1));
      if (tail === 1)
        tok.source = tok.source.slice(0, -1).trim();
      if (tail > 0 && tok.mode === '' ||
        tail !== -1 && tok.mode === 'decl')

      while (i < tokens.length) {
        let t = tokens[i++];
        // 不检查缩进, 忽略注释
        if (t.source.startsWith('//')) continue;

        if (t.source.startsWith('/*')) {
          while (!t.source.endsWith('*/') &&
            i < tokens.length) {
            t = tokens[i++];
          }
          continue;
        }

        tail = t.source.indexOf(' //');
        tok.source += tail === -1 && t.source ||
          t.source.substring(0, tail).trimRight();

        tail = CONTINUATION.indexOf(tok.source.charAt(tok.source.length - 1));

        if (tail === 1)
          tok.source = tok.source.slice(0, -1).trim();

        if (tail === -1 || tail === 0 && tok.mode === '')
          break;
      }

      if (tok.mode === 'decl') {
        tok.key = tok.source.substring(0, pos - 1).trimRight();
        tok.val = tok.source.substring(pos).trimLeft();
      }
    }

    return root;
  }

  /**
   * 格式化输出 root.nodes
   * @param  {object} root 解析后的节点树
   * @return {string} CSS  无花括号两空格缩进格式
   */
  format(root) {
    let fmt = '',
        sp = '\n';
    this.walk(root.nodes, null, (n, c, i, ns) => {
      if (fmt) fmt += sp;
      switch (n.mode) {
        case 'comment':
          fmt += n.source.replace('\n', sp + ' ');
          break;
        case 'decl':
          fmt += n.key + ': ' + n.val;
          break;
        default: // block, rule
          fmt += n.source;
          break;
      }
      if (!i && n.nodes && n.nodes.length) {
        sp += '  ';
      }else if (i && i + 1 === ns.length) {
        sp = sp.slice(0, -2);
      }
      return true;
    });

    return fmt;
  }

  /**
   * 遍历 this.result 所有节点拼接编译插件的编译结果.
   * 未被编译的节点和其子节点被抛弃.
   * @return {string}  body 编译后的函数主体代码;
   */
  compile() {
    let root = this.result, plugins = this.plugins;
    if (!root || root.mode != 'root')
      return '';
    let ctx = {body: ''};
    let compile = (item, ctx, index, nodes) => {
      let body;
      plugins.some((plugin) => {
        if (typeof plugin.compile === 'function') {
          body = plugin.compile(item, index, nodes);
          return body != null;
        }});

      if (!body || body === ' ') return false;

      let pos = body.indexOf('...');

      if (pos !== -1) {
        if (body.indexOf('...', pos + 1) !== -1)
          throw new Error(util.info('Nested placeholders too much', item));

        if (!item.nodes || !item.nodes.length)
          throw new Error(util.info('Nested placeholders can not be used for empty nodes', item));
      }

      if (item.nodes && item.nodes.length) {
        let child = {body: ''};
        this.walk(item.nodes, child, compile);
        if (pos !== -1)
          body = body.substring(0, pos) + child.body + body.substring(pos + 3);
        else
          body += '\n' + child.body;
      }

      ctx.body += body + '\n';
      return false;
    };

    this.walk(root.nodes, ctx, compile);
    return ctx.body;
  }

  /**
   * 返回 Function(params, this.compile(this.result + ';return '+ params.split(',')[0]))
   *
   * @param  {?string} params 形参, 缺省为 'ctx'
   * @return {object}  ctx
   */
  build(params) {
    params = params || 'ctx';

    return Function( // jshint ignore:line
        params,
        this.compile() + ';return ' + params.split(',')[0]
    );
  }

  /**
   * 包装 process, build 并返回执行结果
   * @param  {string}  source CSS 源码
   * @param  {?string} params 形参, 缺省为 'ctx'
   * @param  {?array}  args   实参, 缺省为 [context()]
   * @return {object}
   */
  run(source, params, args) {
    return this.process(source).build(params)(...(args || [context()]));
  }

  /**
   * 使用 nodes.forEach 深度遍历节点树并调用 callback(item, context, index, nodes).
   * 如果 callback 返回非真值, item.nodes 将不参与遍历.
   * @param  {array} nodes
   * @param  {Object} context 上下文
   * @param  {function(object,object,number,array):Boolean} callback 回调函数
   * @return {this}
   */
  walk(nodes, context, callback) {
    if (nodes && typeof nodes.forEach === 'function')
    nodes.forEach((item, index) => {
      if (callback(item, context, index, nodes) && item.nodes)
        this.walk(item.nodes, context, callback);
    }, this);

    return this;
  }
}

module.exports = function(plugins) {
  return new PowCSS(plugins);
};

}).call(this,require('_process'))

},{"./compiler":2,"./context":3,"./lineify":4,"./util":5,"_process":1}]},{},[])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/process/browser.js","lib/compiler.js","lib/context.js","lib/lineify.js","lib/util.js","lib/powcss.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","const IFX = /if[ ]+([_$a-zA-Z]+)[ ]*=/,\n  util =  require('./util');\n\n/**\n * PowCSS 缺省的 Compiler 实现.\n * 所有方法采用原生 js 语法, 要求源码自带嵌套占位符 '...'.\n */\nclass Compiler{\n\n  /**\n   * 构造, 参数用来对 this 进行扩展.\n   * 缺省 this.ctx = 'ctx' 表示 context 的形参名\n   */\n  constructor(...extend) {\n    extend.forEach((ext) => {\n      if (typeof ext === 'function')\n        this[ext.name] = ext;\n      else if (Object.prototype.toString.call(ext) === '[object Object]') {\n        for (let key in ext) {\n          this[key] = ext[key];\n        }\n      }\n    });\n    this.ctx = this.ctx || 'ctx';\n  }\n\n  /**\n   * compile 接口\n   */\n  compile(n, i, ns) {\n    return this.decl(n) ||\n      this.if(n) ||\n      this.each(n) ||\n      this.let(n) ||\n      this.comment(n) ||\n      this.rule(n);\n  }\n\n  /**\n   * 编译 n.mode === 'comment' 的节点, '/*!' 开头的顶层注释被保留, 其它被抛弃.\n   */\n  comment(n) {\n    if (n.mode !== 'comment') return;\n    if (n.column === 1 && n.source[1] === '*' && n.source[2] === '!'){\n      let c = JSON.stringify(n.source);\n      return `${this.ctx}.open(${c}).close();`;\n    }\n    return ' ';\n  }\n\n  /**\n   * 编译 !n.mode 的节点为规则节点\n   */\n  rule(n) {\n    if (n.mode) return;\n    let c = n.source.indexOf('${') === -1 && '\\'' || '`';\n    return n.nodes && n.nodes.length &&\n    `${this.ctx}.open(${c}${n.source}${c});\n...${this.ctx}.close();` ||\n    `${this.ctx}.open(${c}${n.source}${c}).close();`;\n  }\n\n  /**\n   * 编译 n.mode === 'decl' 的节点\n   */\n  decl(n) {\n    if (n.mode !== 'decl') return;\n\n    let c = n.key.indexOf('${') === -1 && '\\'' || '`',\n      v = n.val.endsWith(';') ?\n        n.val.substring(0, n.val.length - 1) :\n        n.val,\n      d = v.indexOf('${') === -1 && '\\'' || '`';\n\n    return `${this.ctx}.decl(${c}${n.key}${c},${d}${v}${d});`;\n  }\n\n  /**\n   * if 语句, 原生语法:\n   *    if(expr) code;\n   *    if (expr) code;\n   */\n  if(n) {\n    if (n.source.startsWith('if(') || n.source.startsWith('if ('))\n      return n.source;\n  }\n\n  /**\n   * each 语句, 原生语法:\n   *\n   *   each(expr, (val, key)=>{code});\n   *   ctx.each(expr, (val, key)=>{code});\n   *\n   */\n  each(n) {\n    if (n.source.startsWith(`${this.ctx}.each(`))\n      return n.source;\n    if (n.source.startsWith('each(')) return this.ctx + '.' + n.source;\n  }\n\n  /**\n   * let 语句, 原生语法:\n   *\n   *   let v1 = expr;\n   *   let [v1,v2] = [expr, expr]; // ES6 解构赋值\n   *   let v1 = expr; code;\n   */\n  let(n) {\n    if (n.source.startsWith('let ')) return n.source;\n  }\n\n}\n\nmodule.exports = function(...extend) {\n  return new Compiler(...extend);\n};\n","/**\n * @typedef {object} Rule   抽象规则\n * @property {string} name  规则名, 也可能是个定义值, 比如 @charset\n * @property {?object<string, string|Rule>} decls 键值声明\n */\n\n/**\n * PowCSS 缺省的 Context 实现.\n * 该实现不分析 CSS 规则的合法性, 只提供结构上的操作和一些辅助方法.\n * 如果要对结果进行再次处理, 推荐使用 walk 方法.\n *\n * @property {Rule}   rule  当前维护的规则, 初始 null\n * @property {Rule[]} rules 最终的规则数组\n * @property {Rule[]} stack 当前规则的 parent 栈\n */\nclass Context {\n  /**\n   * 构造, 参数用来对 this 进行扩展.\n   */\n  constructor(...extend) {\n    extend.forEach((ext) => {\n      if (typeof ext === 'function')\n        this[ext.name] = ext;\n      else if (Object.prototype.toString.call(ext) === '[object Object]') {\n        for (let key in ext) {\n          this[key] = ext[key];\n        }\n      }\n    });\n    this.reset();\n  }\n\n  /**\n   * 重置 .rule, .rules, .stack 为初始状态\n   * @return {this}\n   */\n  reset() {\n    this.rule = null;\n    this.rules = [];\n    this.stack = [];\n    return this;\n  }\n  /**\n   * 遍历 x 回调 callback(val, key)\n   * @param  {object|array}   x\n   * @param  {Function( *, string)} callback 参数顺序 (val, key)\n   * @return {this}\n   */\n  each(x, callback) {\n    if (Array.isArray(x)) {\n      x.forEach(callback);\n    }else\n      Object.keys(x).forEach(function(key) {\n        callback(x[key], key);\n      });\n    return this;\n  }\n\n  /**\n   * 开启一个具名规则并替换 name 中的占位符 '&', 该方法必须与 close 成对使用.\n   * 嵌套使用时 this.stack 会增长.\n   * @param  {string} name\n   * @return {this}\n   */\n  open(name) {\n    if (this.rule) {\n      this.stack.push(this.rule);\n      if (name.indexOf('&') !== -1)\n        name = name.replace(/&/g, this.rule.name);\n\n      if (!this.rule.decls) {\n        if (this.rule.name[0] === '@') {\n          this.rule.decls = [];\n          this.stack.push(this.rules);\n          this.rules = this.rule.decls;\n        }else if (\n          this.rule.name[0] !== '/' &&\n          this.rule === this.rules[this.rules.length - 1]\n         ) {\n          this.rules.pop();\n        }\n      }\n    }\n    this.rule = {name};\n    this.rules.push(this.rule);\n    return this;\n  }\n\n  /**\n   * 关闭当前的规则, this.stack 会减少, 该方法必须与 .open 成对使用.\n   * @return {this}\n   */\n  close() {\n    this.rule = this.stack.pop();\n    if (Array.isArray(this.rule)) {\n      this.rules = this.rule;\n      return this.close();\n    }\n    return this;\n  }\n\n  /**\n   * 返回 this.rule.name\n   * @return {string}\n   */\n  name() {\n    return this.rule && this.rule.name || '';\n  }\n\n  /**\n   * 返回或设置当前规则的 key 声明\n   * @param  {string}  key\n   * @param  {?string} val\n   * @return {string}\n   */\n  decl(key, val) {\n    if (val) {\n      if (!this.rule.decls)\n        this.rule.decls = {};\n      this.rule.decls[key] = val;\n      return val;\n    }\n    return this.rule.decls[key] || '';\n  }\n\n  /**\n   * 输出 this.rules 为 CSS 源码\n   * @return {string} css\n   */\n  toCSS() {\n    let toCSS = (css, rule)=> {\n      if (rule.decls) {\n        css += rule.name + ' {\\n';\n        if (Array.isArray(rule.decls)) {\n          css += rule.decls.reduce(toCSS, '');\n        }else for (let key in rule.decls) {\n          if (typeof rule.decls[key] === 'string')\n            css += key + ': ' + rule.decls[key] + ';\\n';\n          else\n            throw new Error('decls must be a string or array: ' + rule.name + '{' + key + '}');\n        }\n        css += '}\\n';\n      }else if (rule.name[0] === '/') // comment\n        css += rule.name + '\\n';\n      else if (rule.name[0] === '@') // 有些规则只是为了嵌套 '&', 没有 decls\n        css += rule.name + ';\\n';\n      else\n        throw new Error('Unexpected bare rule: ' + rule.name);\n      return css;\n    };\n\n    return this.rules.reduce(toCSS, '');\n  }\n\n  /**\n   * 遍历 this.rules 调用 context 的 open, close, decl 方法.\n   * context 的 open, close 返回的对象会用于后续的迭代.\n   * 任何一个方法返回非真值会终止遍历.\n   * @param  {object}  context  实现 open, close, decl 方法的对象\n   * @return {boolean} finished 是否完全遍历\n   */\n  walk(context) {\n    let walk = function(rule) {\n      let self = this;\n      if (rule.decls) {\n        self = self.open(rule.name);\n        if (Array.isArray(rule.decls)) {\n          if (!rule.decls.every(walk, self))\n            return false;\n        }else for (let key in rule.decls) {\n          if (typeof rule.decls[key] === 'string') {\n            if (!self.decl(key, rule.decls[key])) return false;\n          }else {\n            throw new Error('decls must be a string or array: ' + rule.name + '{' + key + '}');\n          }\n        }\n      }else if (rule.name[0] === '/' || rule.name[0] === '@') {\n        self = self.open(rule.name);\n      }else {\n        throw new Error('Unexpected bare rule: ' + rule.name);\n      }\n      if (self) self = self.close();\n      return !!self;\n    };\n    return this.rules.every(walk, context);\n  }\n}\n\nmodule.exports = function(...extend) {\n  return new Context(...extend);\n};\n","/**\n * lineify 是个非空白行扫描器, 扫描并返回非空白行信息.\n * @param {string} source 待扫描的字符串\n */\nclass lineify{\n  constructor(source) {\n    this.crlf = source.indexOf('\\r\\n') != -1 && '\\r\\n' ||\n      source.indexOf('\\r') != -1 && '\\r' || '\\n';\n    this.crlfLength = this.crlf.length;\n\n    this.bol = 0;\n    this.eol = 0;\n    this.column = 1;\n    this.line = 1;\n    this.source = source;\n    this.scan(null);\n  }\n\n  /**\n   * 返回扫描到的非空白行字符串和位置信息, 并前进. 结构:\n   *   {source, offset, line, column}\n   * @return {Object|null} token 返回 null 表示 EOF\n   */\n  scan() {\n    let tok = {\n      source: this.source.substring(this.bol, this.eol).trimRight(),\n      offset: this.bol,\n      line: this.line,\n      column: this.column\n    };\n\n    if (this.eol === this.source.length) {\n      this.bol = this.eol;\n      return tok.source && tok || null;\n    }\n\n    if (this.eol) {\n      this.bol = this.eol + this.crlfLength;\n      this.line++;\n      this.column = 1;\n    }\n\n    this.eol = this.source.indexOf(this.crlf, this.bol);\n\n    if (this.eol === -1)\n      this.eol = this.source.length;\n\n    while (1) {\n      let c = this.source.charCodeAt(this.bol);\n      if (c === 32 || c === 9) {\n        this.bol++;\n        this.column++;\n        continue;\n      }\n\n      if (this.eol !== this.bol) break;\n      if (this.eol === this.source.length) break;\n\n      this.line++;\n      this.column = 1;\n\n      this.bol = this.eol + this.crlfLength;\n      this.eol = this.source.indexOf(this.crlf, this.bol);\n\n      if (this.eol === -1)\n        this.eol = this.source.length;\n    }\n\n    return tok;\n  }\n}\n\nmodule.exports = function(source) {\n  return new lineify(source);\n};\n","const toString = Object.prototype.toString;\n\n/**\n * 辅助方法集合\n */\nlet util = {\n  /**\n   * 返回包含位置信息的字符串, 常用于出错信息\n   * @param  {string}  message 自定义信息\n   * @param  {object}  loc     含有 line, column 的位置信息\n   * @param  {?string} at      缺省为 <anonymous>\n   * @return {string}\n   */\n  info: function(message, loc, at) {\n    return `${message} at: ${at || '<anonymous>'}:${loc.line}:${loc.column}`;\n  },\n  /**\n   * isObject\n   * @param  {*} x\n   * @return {Boolean}\n   */\n  isObject: function(x) {\n    return toString.call(x) === '[object Object]';\n  },\n  /**\n   * isNumber\n   * @param  {*} x\n   * @return {Boolean}\n   */\n  isNumber: function(x) {\n    return toString.call(x) === '[object Number]';\n  },\n  /**\n   * isArray\n   * @param  {*} x\n   * @return {Boolean}\n   */\n  isArray: function(x) {\n    return Array.isArray(x);\n  },\n  /**\n   * isString\n   * @param  {*} x\n   * @return {Boolean}\n   */\n  isString: function(x) {\n    return typeof x === 'string';\n  },\n  /**\n   * isFunction\n   * @param  {*} x\n   * @return {Boolean}\n   */\n  isFunction: function(x) {\n    return typeof x === 'function';\n  }\n};\n\nmodule.exports = util;\n","const lineify = require('./lineify'),\n  compiler = require('./compiler'),\n  context = require('./context'),\n  util =  require('./util'),\n  CONTINUATION = '&\\\\,+-/*|=([';\n\n/**\n * PowCSS 负责解析 source 为节点树, 并拼接编译器的编译结果.\n * 在 PowCSS 中的插件就是 compiler, compiler 负责与 context 配合.\n */\nclass PowCSS {\n  /**\n   * @param  {?Compiler[]} plugins 编译器数组, 缺省为 [compiler()]\n   */\n  constructor(plugins) {\n    this.plugins = plugins && plugins.length && plugins || [compiler()];\n  }\n\n  /**\n   * 使用一个编译器插件\n   * @param  {Compiler} plugin\n   * @return {this}\n   */\n  use(plugin) {\n    if (plugin)\n      this.plugins.push(plugin);\n    return this;\n  }\n\n  /**\n   * 包装 this.result = this.parse(source) 并返回 this.\n   * @param  {string}  source  源码\n   * @return {this}\n   */\n  process(source) {\n    this.result = source;\n    if (!source) return this;\n    this.result = this.parse(source);\n    return this;\n  }\n\n  /**\n   * 解析 source 为节点树.\n   * 节点类型:\n   *   1. root    {mode:'root', nodes}\n   *   1. comment {mode:'comment', source} 只保留非行尾注释\n   *   1. decl    {mode:'decl', source, key, val}\n   *   1. pending {mode:'', source, nodes}\n   *\n   * 即所有 !mode 的节点需要通过编译插件进行确认\n   * @param  {string} source 源码\n   * @return {object} root 节点树\n   */\n  parse(source) {\n    if (typeof source !== 'string') return source;\n\n    let root = {\n          offset: 0,\n          line: 0,\n          column: 0,\n          mode: 'root',\n          nodes: []\n        },\n        parent = root,\n        stack = [],\n        i = 0,\n        tokens = [],\n        lines = lineify(source),\n        tok = lines.scan(),\n        algin = tok && tok.column || 1;\n\n    while (tok) {\n      tokens.push(tok);\n      tok = lines.scan();\n    }\n\n    while (i < tokens.length) {\n      tok = tokens[i];\n\n      while (tok.column <= parent.column) {\n        parent = stack.pop();\n        algin = parent.nodes[parent.nodes.length - 1].column;\n      }\n\n      // 传统花括号块格式\n      if (tok.source[0] === '}') {\n        let last = parent.nodes[parent.nodes.length - 1];\n        if (!last.source.endsWith('{'))\n          throw new Error(util.info(`Unpaired brackets from ${last.line}:${last.column}` , tok));\n        last.source = last.source.slice(0, -1).trimRight();\n        i++;\n        continue;\n      }\n\n      if (tok.column > algin) {\n        algin = tok.column;\n        tok.nodes = tok.nodes || [];\n        stack.push(parent);\n        if (!parent.nodes.length)\n          throw new Error(util.info('PowCSS broken', tok));\n        parent = parent.nodes[parent.nodes.length - 1];\n        continue;\n      }\n      i++;\n      parent.nodes.push(tok);\n\n      if (tok.source.startsWith('//')) {\n        tok.mode = 'comment';\n        continue;\n      }\n\n      if (tok.source.startsWith('/*')) {\n        if (tok.source.endsWith('*/'))\n          tok.mode = 'comment';\n        else while (i < tokens.length) {\n          tok.source += '\\n' + tokens[i++].source;\n          if (tok.source.endsWith('*/')) {\n            tok.mode = 'comment';\n            break;\n          }\n        }\n        if (tok.mode !== 'comment')\n          throw new Error(util.info('Unclosed comments', tok));\n        continue;\n      }\n\n      let tail = tok.source.indexOf(' //');\n\n      /**\n       * 行尾注释必须以 ' //' 开头\n       */\n      if (tail !== -1)\n        tok.source = tok.source.substring(0, tail).trim();\n\n      /**\n       * 属性名和值不能以 '@' 开头\n       * 属性分隔符 ':' 之后必须是空格或者换行 `:[ \\n]`\n       */\n      let pos = tok.source[0] === '@' && -1 || tok.source.indexOf(':') + 1;\n      tok.mode = pos > 0 &&\n        (pos === tok.source.length || tok.source[pos] === ' ') &&\n        'decl' || '';\n\n      tok.nodes = [];\n\n      /**\n       * 续行符包括 `\\\\,+-/*|=([`\n       */\n      tail = CONTINUATION.indexOf(tok.source.charAt(tok.source.length - 1));\n      if (tail === 1)\n        tok.source = tok.source.slice(0, -1).trim();\n      if (tail > 0 && tok.mode === '' ||\n        tail !== -1 && tok.mode === 'decl')\n\n      while (i < tokens.length) {\n        let t = tokens[i++];\n        // 不检查缩进, 忽略注释\n        if (t.source.startsWith('//')) continue;\n\n        if (t.source.startsWith('/*')) {\n          while (!t.source.endsWith('*/') &&\n            i < tokens.length) {\n            t = tokens[i++];\n          }\n          continue;\n        }\n\n        tail = t.source.indexOf(' //');\n        tok.source += tail === -1 && t.source ||\n          t.source.substring(0, tail).trimRight();\n\n        tail = CONTINUATION.indexOf(tok.source.charAt(tok.source.length - 1));\n\n        if (tail === 1)\n          tok.source = tok.source.slice(0, -1).trim();\n\n        if (tail === -1 || tail === 0 && tok.mode === '')\n          break;\n      }\n\n      if (tok.mode === 'decl') {\n        tok.key = tok.source.substring(0, pos - 1).trimRight();\n        tok.val = tok.source.substring(pos).trimLeft();\n      }\n    }\n\n    return root;\n  }\n\n  /**\n   * 格式化输出 root.nodes\n   * @param  {object} root 解析后的节点树\n   * @return {string} CSS  无花括号两空格缩进格式\n   */\n  format(root) {\n    let fmt = '',\n        sp = '\\n';\n    this.walk(root.nodes, null, (n, c, i, ns) => {\n      if (fmt) fmt += sp;\n      switch (n.mode) {\n        case 'comment':\n          fmt += n.source.replace('\\n', sp + ' ');\n          break;\n        case 'decl':\n          fmt += n.key + ': ' + n.val;\n          break;\n        default: // block, rule\n          fmt += n.source;\n          break;\n      }\n      if (!i && n.nodes && n.nodes.length) {\n        sp += '  ';\n      }else if (i && i + 1 === ns.length) {\n        sp = sp.slice(0, -2);\n      }\n      return true;\n    });\n\n    return fmt;\n  }\n\n  /**\n   * 遍历 this.result 所有节点拼接编译插件的编译结果.\n   * 未被编译的节点和其子节点被抛弃.\n   * @return {string}  body 编译后的函数主体代码;\n   */\n  compile() {\n    let root = this.result, plugins = this.plugins;\n    if (!root || root.mode != 'root')\n      return '';\n    let ctx = {body: ''};\n    let compile = (item, ctx, index, nodes) => {\n      let body;\n      plugins.some((plugin) => {\n        if (typeof plugin.compile === 'function') {\n          body = plugin.compile(item, index, nodes);\n          return body != null;\n        }});\n\n      if (!body || body === ' ') return false;\n\n      let pos = body.indexOf('...');\n\n      if (pos !== -1) {\n        if (body.indexOf('...', pos + 1) !== -1)\n          throw new Error(util.info('Nested placeholders too much', item));\n\n        if (!item.nodes || !item.nodes.length)\n          throw new Error(util.info('Nested placeholders can not be used for empty nodes', item));\n      }\n\n      if (item.nodes && item.nodes.length) {\n        let child = {body: ''};\n        this.walk(item.nodes, child, compile);\n        if (pos !== -1)\n          body = body.substring(0, pos) + child.body + body.substring(pos + 3);\n        else\n          body += '\\n' + child.body;\n      }\n\n      ctx.body += body + '\\n';\n      return false;\n    };\n\n    this.walk(root.nodes, ctx, compile);\n    return ctx.body;\n  }\n\n  /**\n   * 返回 Function(params, this.compile(this.result + ';return '+ params.split(',')[0]))\n   *\n   * @param  {?string} params 形参, 缺省为 'ctx'\n   * @return {object}  ctx\n   */\n  build(params) {\n    params = params || 'ctx';\n\n    return Function( // jshint ignore:line\n        params,\n        this.compile() + ';return ' + params.split(',')[0]\n    );\n  }\n\n  /**\n   * 包装 process, build 并返回执行结果\n   * @param  {string}  source CSS 源码\n   * @param  {?string} params 形参, 缺省为 'ctx'\n   * @param  {?array}  args   实参, 缺省为 [context()]\n   * @return {object}\n   */\n  run(source, params, args) {\n    return this.process(source).build(params)(...(args || [context()]));\n  }\n\n  /**\n   * 使用 nodes.forEach 深度遍历节点树并调用 callback(item, context, index, nodes).\n   * 如果 callback 返回非真值, item.nodes 将不参与遍历.\n   * @param  {array} nodes\n   * @param  {Object} context 上下文\n   * @param  {function(object,object,number,array):Boolean} callback 回调函数\n   * @return {this}\n   */\n  walk(nodes, context, callback) {\n    if (nodes && typeof nodes.forEach === 'function')\n    nodes.forEach((item, index) => {\n      if (callback(item, context, index, nodes) && item.nodes)\n        this.walk(item.nodes, context, callback);\n    }, this);\n\n    return this;\n  }\n}\n\nmodule.exports = function(plugins) {\n  return new PowCSS(plugins);\n};\n"]}
// powcss demonstration
const powcss=require('powcss');
let pre = document.createElement('pre');
pre.textContent = powcss([]).run(
`
let /**/
  rem=(px) => px/16 +'rem', /*Line-Continuation*/
  spacing=(tracking)=>tracking/12 +'rem',
	cols = [1,2,3,4].join(',.col-')

.col-\${cols}
    display: block
    letter-spacing: \${spacing(-1.5)}

`
).toCSS();

document.body.append(pre);
;}, 0)

package.json

{
  "name": "requirebin-sketch",
  "version": "1.0.0",
  "dependencies": {
    "powcss": "1.0.5"
  }
}

page-body.html

<!-- contents of this file will be placed inside the <body> -->

page-head.html

<!-- contents of this file will be placed inside the <head> -->

requirebin.md

made with requirebin