wrap
@param  {[type]} trunk [description]
@return {[type]}       [description]
173306
function wrap(trunk, injector) {

  let res = trunk.toString('utf8').replace(/\<body[\s\S]*?\>/, function (all) {
    return all + (Array.isArray(injector) ? injector.join("") : injector || '');
  })
  return res;
}
823019
function wrap(file, isCircularDependency) {
  const header =
    `/*== ${file.relpath} ==*/\n` +
    `$m['${file.id}'] = ${isCircularDependency ? "function () {\n$m['" + file.id + "'] = " : ''}{ exports: {} };`;
  const footer = `${isCircularDependency ? '};\n' : ''}/*≠≠ ${file.relpath} ≠≠*/`;

  return [header, footer];
}
86177
function _createTheadOrTbodyHtml(trs, wrapperNodeName) {
  let html = '';

  if (trs.length) {
    html = trs.map(tr => {
      const tdHtml = tr.map(_createCellHtml).join('');

      return `<tr>${tdHtml}</tr>`;
    }).join('');
    html = `<${wrapperNodeName}>${html}</${wrapperNodeName}>`;
  }

  return html;
}
702125
function wrapify(fn, before = noop, after = noop) {
  return function(...args) {
    before.call(this);
    var ret = fn.call(this, ...args);
    after.call(this);
    return ret;
  };
}
700569
function wrap(fn) {
  // Error handling middleware
  if (fn.length === 4) {
    return async function wrappedErrorHandler(error, req, res, next) {
      next = _once(next);
      try {
        await fn(error, req, res, next);
        res.headersSent ? null : next();
      } catch(err) {
        res.headersSent ? null : next(err);
      }
    };
  }

  return async function wrappedMiddleware(req, res, next) {
    next = _once(next);
    try {
      await fn(req, res, next);
      res.headersSent ? null : next();
    } catch(err) {
      res.headersSent ? null : next(err);
    }
  };
}
126140
function wrapped (del1, del2, pattFn, nodeFn, inp) {
    if (inp.takeAPeek(del1)) {
      var res = pattFn(inp.skipWs());
      if (inp.skipWs().takeAPeek(del2)) return nodeFn(res);
      else syntaxError(inp, "Expected " + del2);
    }
  }
428772
def _wrap(self, ret):
        
        if self.chained:
            self._wrapped = ret
            return self
        else:
            return ret
491215
function wrap (factory, node, tag) {
    // If there is a previous node that is not text, insert a new line to
    // for 
    if (node.previousSibling != null && node.previousSibling.nodeType != 3) {
        var newline = factory.createTextNode("\n");
        body.insertBefore(newline, node);
    }
    var wrapper = factory.createElement(tag);
    node.parentNode.insertBefore(wrapper, node);
    wrapper.appendChild(node);
    return wrapper;
  }
568882
function wrap(err, js) {
		if (err) { return next(err); }

		var deps = exports.dependencies(id, js), params = [], undef = '';

		// make sure require, exports, and module are properly passed into the factory
		if (/\brequire\b/.test(js)) { params.push('require'); }
		if (/\bexports\b/.test(js)) { params.push('exports'); }
		if (/\bmodule\b/.test(js)) { params.push('module'); }

		// make sure code follows the `exports` path instead of `define` path once wrapped
		if (/\bdefine\.amd\b/.test(js)) { undef = 'var define;'; }

		if (deps.length) {
			deps = ',' + JSON.stringify(params.concat(deps));
		} else if (params.length) {
			params = [ 'require', 'exports', 'module' ];
		}

		js = 'define(' + JSON.stringify(id) + deps + ',function(' + params + ')' +
				'{' + js + '\n' + undef + '}' + // rely on hoisting for define
			');\n';
		next(null, js);
	}
187214
function wrapHandler(handler) {
  return function (state) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

    return _lodash2.default.assign({}, state, handler.apply(undefined, [state].concat(args)));
  };
}
1106558
function wrapMethod(app,fn){
    //Override original express method
    return function(){
        let args = Array.prototype.slice.call(arguments)
        //Check if any middleware argument is a generator function
        for( let i=0; i<args.length; i++ ){
            //Wrap this if necessary
            args[i] = controllerWrapper(args[i])
        }
        
        //Call original method handler
        return fn.apply(app,args)
    }
}
1177851
function wrap(value) {
    var raw;
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    raw = this.unwrapRaw(value);
    if (raw) {
      return raw;
    }
    if (typeof value === 'number') {
      return value;
    }
    return this._wrapString(value + '');
  }
636041
def array_wrap(object)
      if object.nil?
        []
      elsif object.respond_to?(:to_ary)
        object.to_ary || [object]
      else
        [object]
      end
    end
465476
function wrap (rule) {
  return ($) => {
    let value = rule($)
    if (typeof value !== 'string') return

    // remove extra whitespace
    value = value.replace(/\s+/g, ' ')
    value = value.trim()

    return value
  }
}
255001
function (node, wrapperName) {
            var parent = node.parentNode;
            var wrapper = $('<' + wrapperName + '>')[0];

            parent.insertBefore(wrapper, node);
            wrapper.appendChild(node);

            return wrapper;
        }
153428
function wrap(body, extKeys) {
    const wrapper = [
        '(function (exports, require, module, __filename, __dirname',
        ') { ',
        '\n});'
    ];

    extKeys = extKeys ? `, ${extKeys}` : '';

    return wrapper[0] + extKeys + wrapper[1] + body + wrapper[2];
}
30487
function unwrap() {
                var nodes = Array.prototype.slice.call(el.childNodes),
                    wrapper = void 0;

                nodes.forEach(function (node) {
                    wrapper = node.parentNode;
                    dom(node).insertBefore(node.parentNode);
                    dom(wrapper).remove();
                });

                return nodes;
            }