/* package private
548012
static Predicate<CtClass> createIncludePredicate(@Nullable final String[] classes) {
        final Set<PathMatcher> includeSet;
        if (classes != null && classes.length != 0) {
            includeSet = createPathMatcherSet(classes);
        } else {
            return ctClass -> true;
        }
        return createMatchingPredicate(includeSet);
    }
888270
function consumeKeywordOrFunction(stream) {
	const kw = consumeKeyword(stream);
	if (kw) {
		const args = consumeArgumentList(stream);
		return args ? new FunctionCall(kw.toString(), args) : kw;
	}
}
528884
function() {
    const self = this;
    const outBindPrep = this._prepOutbindings(
      this.single.insert,
      this.single.returning
    );
    const outBinding = outBindPrep.outBinding;
    const returning = outBindPrep.returning;
    const insertValues = outBindPrep.values;

    if (
      Array.isArray(insertValues) &&
      insertValues.length === 1 &&
      _.isEmpty(insertValues[0])
    ) {
      return this._addReturningToSqlAndConvert(
        'insert into ' +
          this.tableName +
          ' (' +
          this.formatter.wrap(this.single.returning) +
          ') values (default)',
        outBinding[0],
        this.tableName,
        returning
      );
    }

    if (
      _.isEmpty(this.single.insert) &&
      typeof this.single.insert !== 'function'
    ) {
      return '';
    }

    const insertData = this._prepInsert(insertValues);

    const sql = {};

    if (_.isString(insertData)) {
      return this._addReturningToSqlAndConvert(
        'insert into ' + this.tableName + ' ' + insertData,
        outBinding[0],
        this.tableName,
        returning
      );
    }

    if (insertData.values.length === 1) {
      return this._addReturningToSqlAndConvert(
        'insert into ' +
          this.tableName +
          ' (' +
          this.formatter.columnize(insertData.columns) +
          ') values (' +
          this.formatter.parameterize(insertData.values[0]) +
          ')',
        outBinding[0],
        this.tableName,
        returning
      );
    }

    const insertDefaultsOnly = insertData.columns.length === 0;
    sql.returning = returning;
    sql.sql =
      'begin ' +
      _.map(insertData.values, function(value, index) {
        const parameterizedValues = !insertDefaultsOnly
          ? self.formatter.parameterize(value, self.client.valueForUndefined)
          : '';
        let subSql = 'insert into ' + self.tableName;

        if (insertDefaultsOnly) {
          // No columns given so only the default value
          subSql +=
            ' (' +
            self.formatter.wrap(self.single.returning) +
            ') values (default)';
        } else {
          subSql +=
            ' (' +
            self.formatter.columnize(insertData.columns) +
            ') values (' +
            parameterizedValues +
            ')';
        }

        let returningClause = '';
        let intoClause = '';
        // ToDo review if this code is still needed or could be dropped
        // eslint-disable-next-line no-unused-vars
        let usingClause = '';
        let outClause = '';

        _.each(value, function(val) {
          if (!(val instanceof BlobHelper)) {
            usingClause += ' ?,';
          }
        });
        usingClause = usingClause.slice(0, -1);

        // Build returning and into clauses
        _.each(outBinding[index], function(ret) {
          const columnName = ret.columnName || ret;
          returningClause += self.formatter.wrap(columnName) + ',';
          intoClause += ' ?,';
          outClause += ' out ?,';

          // Add Helpers to bindings
          if (ret instanceof BlobHelper) {
            return self.formatter.bindings.push(ret);
          }
          self.formatter.bindings.push(new ReturningHelper(columnName));
        });

        // Strip last comma
        returningClause = returningClause.slice(0, -1);
        intoClause = intoClause.slice(0, -1);
        outClause = outClause.slice(0, -1);

        if (returningClause && intoClause) {
          subSql += ' returning ' + returningClause + ' into' + intoClause;
        }

        // Pre bind position because subSql is an execute immediate parameter
        // later position binding will only convert the ? params
        subSql = self.formatter.client.positionBindings(subSql);
        const parameterizedValuesWithoutDefaultAndBlob = parameterizedValues
          .replace('DEFAULT, ', '')
          .replace(', DEFAULT', '')
          .replace('EMPTY_BLOB(), ', '')
          .replace(', EMPTY_BLOB()', '');
        return (
          "execute immediate '" +
          subSql.replace(/'/g, "''") +
          (parameterizedValuesWithoutDefaultAndBlob || value
            ? "' using "
            : '') +
          parameterizedValuesWithoutDefaultAndBlob +
          (parameterizedValuesWithoutDefaultAndBlob && outClause ? ',' : '') +
          outClause +
          ';'
        );
      }).join(' ') +
      'end;';

    sql.outBinding = outBinding;
    if (returning[0] === '*') {
      // Generate select statement with special order by
      // to keep the order because 'in (..)' may change the order
      sql.returningSql = function() {
        return (
          'select * from ' +
          self.tableName +
          ' where ROWID in (' +
          this.outBinding
            .map(function(v, i) {
              return ':' + (i + 1);
            })
            .join(', ') +
          ')' +
          ' order by case ROWID ' +
          this.outBinding
            .map(function(v, i) {
              return 'when CHARTOROWID(:' + (i + 1) + ') then ' + i;
            })
            .join(' ') +
          ' end'
        );
      };
    }

    return sql;
  }
319023
@Override
    public Long put(char key, Long value) {
        verifyStandardSetting(key, value);
        return super.put(key, value);
    }
328607
@SuppressWarnings("unchecked")
	
	/**
	 * 返回列表 key 中，下标为 index 的元素。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，
	 * 以 1 表示列表的第二个元素，以此类推。
	 * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * 如果 key 不是列表类型，返回一个错误。
	 */
	public <T> T lindex(Object key, long index) {
		Jedis jedis = getJedis();
		try {
			return (T)valueFromBytes(jedis.lindex(keyToBytes(key), index));
		}
		finally {close(jedis);}
	}
965292
public static void main(String[] args) {
    for (int i = 0; i < args.length; i++)
      System.out.println("'" + args[i] + "' becomes '" + obfuscate(args[i]) + "'");
  }

  /**
   * Takes a string and returns an obfuscated string with no more than 2x a many characters as the
   * original. Only works in the DEV environment.
   */
  public static String obfuscate(String plaintext) {
    String blargtext = StringMan.encodeBytesToString(mangleArray(plaintext.getBytes()));
    blargtext = StringMan.compressHexString(blargtext);
    return blargtext;
  }

  /** Opposite of {@link #obfuscate(String)} */
  public static String clarify(String blargtext) {
    if (blargtext == null)
      return null;
    byte blargBytes[] = decodeStringToBytes(blargtext);
    String plaintext = new String(mangleArray(blargBytes));
    return plaintext;
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static byte[] decodeStringToBytes(String hex) {
    hex = decompressHexString(hex);
    int stringLength = hex.length();
    byte[] b = new byte[stringLength / 2];
    for (int i = 0, j = 0; i < stringLength; i += 2, j++) {
      int high = charToNibble(hex.charAt(i));
      int low = charToNibble(hex.charAt(i + 1));
      b[j] = (byte) ((high << 4) | low);
    }
    return b;
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static int charToNibble(char c) {
    if ('0' <= c && c <= '9')
      return c - '0';
    else if ('a' <= c && c <= 'f')
      return c - 'a' + 0xa;
    else if ('A' <= c && c <= 'F')
      return c - 'A' + 0xa;
    else
      throw new IllegalArgumentException("Invalid hex character: " + c);
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static String decompressHexString(String in) {
    StringBuffer out = new StringBuffer();
    for (int i = 0; i < in.length(); i++) {
      char thisChar = in.charAt(i);
      if (thisChar != '^') {
        out.append(thisChar);
      } else {
        thisChar = in.charAt(i + 1);
        int count = "abcdefghijklmnopqrstuvwxyz01234567890".indexOf(in.charAt(i + 2));
        for (int j = 0; j < count; j++)
          out.append(thisChar);
        i += 2;
      }
    }
    return out.toString();
  }

  /**
   * Takes a given byte array and mangles it by XOR'ing it with a secret garbage hash. It is
   * reversible, so calling mangleArray(mangleArray(blah)) will return the original array.
   * 
   * @return the mangled array (Same size as the input array)
   */
  private static byte[] mangleArray(byte plainBytes[]) {
    if (plainBytes == null)
      return null;
    byte mangled[] = new byte[plainBytes.length];
    byte hash[] = SUPER_SECRET_MANGLE_STRING.getBytes();
    for (int i = 0; i < plainBytes.length; i++) {
      byte current = (byte) (plainBytes[i] ^ hash[i % hash.length]);
      mangled[i] = current;
    }
    return mangled;
  }

}
333125
@SuppressWarnings("squid:S1166") //For the UnsupportedOperationException
    private Script build(CharStream cs) throws ScriptBuilderException {

        Script v = new Script();

        ANTLRBtrplaceSL2Lexer lexer = new ANTLRBtrplaceSL2Lexer(cs);

        ErrorReporter errorReporter = errBuilder.build(v);

        lexer.setErrorReporter(errorReporter);
        CommonTokenStream tokens = new CommonTokenStream(lexer);

        ANTLRBtrplaceSL2Parser parser = new ANTLRBtrplaceSL2Parser(tokens);
        parser.setErrorReporter(errorReporter);

        SymbolsTable t = new SymbolsTable();

        parser.setTreeAdaptor(new BtrPlaceTreeAdaptor(v, model, namingServiceNodes, namingServiceVMs, tpls, errorReporter, t, includes, catalog));

        try {
            BtrPlaceTree tree = (BtrPlaceTree) parser.script_decl().getTree();
            if (tree != null) {
                if (tree.token != null) {
                        tree.go(tree); //Single instruction
                } else {
                    for (int i = 0; i < tree.getChildCount(); i++) {
                            tree.getChild(i).go(tree);
                        }
                    }
            }
        } catch (RecognitionException e) {
            throw new ScriptBuilderException(e.getMessage(), e);
        } catch (UnsupportedOperationException e) {
            //We only keep the error message
            errorReporter.append(0, 0, e.getMessage());
        }
        if (!errorReporter.getErrors().isEmpty()) {
            throw new ScriptBuilderException(errorReporter);
        }
        return v;
    }
1308293
static int[] uniquify(int[] ints) {
		IntSet iset = new IntSet();
		for (int i : ints) {
			iset.add(i);
		}
		return iset.toIntArray();
	}
910919
int unpack(Buffer opb) {
        int i;
    //memset(s,0,sizeof(static_codebook));

        // make sure alignment is correct
        if (opb.read(24) != 0x564342) {
            //    goto _eofout;
            clear();
            return (-1);
        }

        // first the basic parameters
        dim = opb.read(16);
        entries = opb.read(24);
        if (entries == -1) {
            //    goto _eofout;
            clear();
            return (-1);
        }

        // codeword ordering.... length ordered or unordered?
        switch (opb.read(1)) {
            case 0:
                // unordered
                lengthlist = new int[entries];

                // allocated but unused entries?
                if (opb.read(1) != 0) {
                    // yes, unused entries

                    for (i = 0; i < entries; i++) {
                        if (opb.read(1) != 0) {
                            int num = opb.read(5);
                            if (num == -1) {
                                //            goto _eofout;
                                clear();
                                return (-1);
                            }
                            lengthlist[i] = num + 1;
                        } else {
                            lengthlist[i] = 0;
                        }
                    }
                } else {
                    // all entries used; no tagging
                    for (i = 0; i < entries; i++) {
                        int num = opb.read(5);
                        if (num == -1) {
                            //          goto _eofout;
                            clear();
                            return (-1);
                        }
                        lengthlist[i] = num + 1;
                    }
                }
                break;
            case 1: // ordered
            {
                int length = opb.read(5) + 1;
                lengthlist = new int[entries];

                for (i = 0; i < entries;) {
                    int num = opb.read(Util.ilog(entries - i));
                    if (num == -1) {
                        //          goto _eofout;
                        clear();
                        return (-1);
                    }
                    for (int j = 0; j < num; j++, i++) {
                        lengthlist[i] = length;
                    }
                    length++;
                }
            }
            break;
            default:
                // EOF
                return (-1);
        }

        // Do we have a mapping to unpack?
        switch ((maptype = opb.read(4))) {
            case 0:
                // no mapping
                break;
            case 1:
            case 2:
                // implicitly populated value mapping
                // explicitly populated value mapping
                q_min = opb.read(32);
                q_delta = opb.read(32);
                q_quant = opb.read(4) + 1;
                q_sequencep = opb.read(1);

                 {
                    int quantvals = 0;
                    switch (maptype) {
                        case 1:
                            quantvals = maptype1_quantvals();
                            break;
                        case 2:
                            quantvals = entries * dim;
                            break;
                    }

                    // quantized values
                    quantlist = new int[quantvals];
                    for (i = 0; i < quantvals; i++) {
                        quantlist[i] = opb.read(q_quant);
                    }
                    if (quantlist[quantvals - 1] == -1) {
                        //        goto _eofout;
                        clear();
                        return (-1);
                    }
                }
                break;
            default:
                //    goto _eofout;
                clear();
                return (-1);
        }
        // all set
        return (0);
        //    _errout:
        //    _eofout:
        //    vorbis_staticbook_clear(s);
        //    return(-1); 
    }
998414
private Op compile(Token tok, Op next, boolean reverse) {
		Op ret;
		switch (tok.type) {
		case Token.DOT:
			ret = Op.createDot();
			ret.next = next;
			break;

		case Token.CHAR:
			ret = Op.createChar(tok.getChar());
			ret.next = next;
			break;

		case Token.ANCHOR:
			ret = Op.createAnchor(tok.getChar());
			ret.next = next;
			break;

		case Token.RANGE:
		case Token.NRANGE:
			ret = Op.createRange(tok);
			ret.next = next;
			break;

		case Token.CONCAT:
			ret = next;
			if (!reverse) {
				for (int i = tok.size() - 1; i >= 0; i--) {
					ret = compile(tok.getChild(i), ret, false);
				}
			} else {
				for (int i = 0; i < tok.size(); i++) {
					ret = compile(tok.getChild(i), ret, true);
				}
			}
			break;

		case Token.UNION:
			Op.UnionOp uni = Op.createUnion(tok.size());
			for (int i = 0; i < tok.size(); i++) {
				uni.addElement(compile(tok.getChild(i), next, reverse));
			}
			ret = uni; // ret.next is null.
			break;

		case Token.CLOSURE:
		case Token.NONGREEDYCLOSURE:
			Token child = tok.getChild(0);
			int min = tok.getMin();
			int max = tok.getMax();
			if (min >= 0 && min == max) { // {n}
				ret = next;
				for (int i = 0; i < min; i++) {
					ret = compile(child, ret, reverse);
				}
				break;
			}
			if (min > 0 && max > 0)
				max -= min;
			if (max > 0) {
				// X{2,6} -> XX(X(X(XX?)?)?)?
				ret = next;
				for (int i = 0; i < max; i++) {
					Op.ChildOp q = Op
							.createQuestion(tok.type == Token.NONGREEDYCLOSURE);
					q.next = next;
					q.setChild(compile(child, ret, reverse));
					ret = q;
				}
			} else {
				Op.ChildOp op;
				if (tok.type == Token.NONGREEDYCLOSURE) {
					op = Op.createNonGreedyClosure();
				} else { // Token.CLOSURE
					op = Op.createClosure(this.numberOfClosures++);
				}
				op.next = next;
				op.setChild(compile(child, op, reverse));
				ret = op;
			}
			if (min > 0) {
				for (int i = 0; i < min; i++) {
					ret = compile(child, ret, reverse);
				}
			}
			break;

		case Token.EMPTY:
			ret = next;
			break;

		case Token.STRING:
			ret = Op.createString(tok.getString());
			ret.next = next;
			break;

		case Token.BACKREFERENCE:
			ret = Op.createBackReference(tok.getReferenceNumber());
			ret.next = next;
			break;

		case Token.PAREN:
			if (tok.getParenNumber() == 0) {
				ret = compile(tok.getChild(0), next, reverse);
			} else if (reverse) {
				next = Op.createCapture(tok.getParenNumber(), next);
				next = compile(tok.getChild(0), next, reverse);
				ret = Op.createCapture(-tok.getParenNumber(), next);
			} else {
				next = Op.createCapture(-tok.getParenNumber(), next);
				next = compile(tok.getChild(0), next, reverse);
				ret = Op.createCapture(tok.getParenNumber(), next);
			}
			break;

		case Token.LOOKAHEAD:
			ret = Op.createLook(Op.LOOKAHEAD, next,
					compile(tok.getChild(0), null, false));
			break;
		case Token.NEGATIVELOOKAHEAD:
			ret = Op.createLook(Op.NEGATIVELOOKAHEAD, next,
					compile(tok.getChild(0), null, false));
			break;
		case Token.LOOKBEHIND:
			ret = Op.createLook(Op.LOOKBEHIND, next,
					compile(tok.getChild(0), null, true));
			break;
		case Token.NEGATIVELOOKBEHIND:
			ret = Op.createLook(Op.NEGATIVELOOKBEHIND, next,
					compile(tok.getChild(0), null, true));
			break;

		case Token.INDEPENDENT:
			ret = Op.createIndependent(next,
					compile(tok.getChild(0), null, reverse));
			break;

		case Token.MODIFIERGROUP:
			ret = Op.createModifier(next,
					compile(tok.getChild(0), null, reverse),
					((Token.ModifierToken) tok).getOptions(),
					((Token.ModifierToken) tok).getOptionsMask());
			break;

		case Token.CONDITION:
			Token.ConditionToken ctok = (Token.ConditionToken) tok;
			int ref = ctok.refNumber;
			Op condition = ctok.condition == null ? null : compile(
					ctok.condition, null, reverse);
			Op yes = compile(ctok.yes, next, reverse);
			Op no = ctok.no == null ? null : compile(ctok.no, next, reverse);
			ret = Op.createCondition(next, ref, condition, yes, no);
			break;

		default:
			throw new RuntimeException("Unknown token type: " + tok.type);
		} // switch (tok.type)
		return ret;
	}
90742
@Override
  public void setHeader(String key, String value)
  {
    int tail;

    if (_headerSize > 0) {
      tail = (_headerValues[_headerSize - 1].offset()
              + _headerValues[_headerSize - 1].length());
    }
    else {
      tail = 0;
    }

    int keyLength = key.length();
    int valueLength = value.length();
    char []headerBuffer = _headerBuffer;
    
    for (int i = keyLength - 1; i >= 0; i--) {
      headerBuffer[tail + i] = key.charAt(i);
    }

    _headerKeys[_headerSize].init(headerBuffer, tail, keyLength);

    tail += keyLength;

    for (int i = valueLength - 1; i >= 0; i--) {
      headerBuffer[tail + i] = value.charAt(i);
    }

    _headerValues[_headerSize].init(headerBuffer, tail, valueLength);
    _headerSize++;
    // XXX: size
  }
605934
function checkSpacingForProperty(node) {
            if (node.static) {
                checkSpacingAroundFirstToken(node);
            }
            if (node.kind === "get" ||
                node.kind === "set" ||
                (
                    (node.method || node.type === "MethodDefinition") &&
                    node.value.async
                )
            ) {
                const token = sourceCode.getTokenBefore(
                    node.key,
                    tok => {
                        switch (tok.value) {
                            case "get":
                            case "set":
                            case "async":
                                return true;
                            default:
                                return false;
                        }
                    }
                );

                if (!token) {
                    throw new Error("Failed to find token get, set, or async beside method name");
                }


                checkSpacingAround(token);
            }
        }
113640
@Override
  public PathImpl schemeWalk(String userPath,
                         Map<String,Object> attributes,
                         String filePath,
                         int offset)
  {
    if (! isWindows()) {
      return super.schemeWalk(userPath, attributes, filePath, offset);
    }

    String canonicalPath;

    if (filePath.length() < offset + 2) {
      return super.schemeWalk(userPath, attributes, filePath, offset);
    }

    char ch1 = filePath.charAt(offset + 1);
    char ch2 = filePath.charAt(offset);

    if ((ch2 == '/' || ch2 == _separatorChar)
        && (ch1 == '/' || ch1 == _separatorChar))
      return super.schemeWalk(userPath, attributes,
                              convertFromWindowsPath(filePath.substring(offset)), 0);
    else
      return super.schemeWalk(userPath, attributes, filePath, offset);
  }
339099
private static void deeplyAppendParameter(StringBuffer sbuf, Object o,
                                            Map<Object[], Void> seenMap) {
    if (o == null) {
      sbuf.append("null");
      return;
    }
    if (!o.getClass().isArray()) {
      safeObjectAppend(sbuf, o);
    } else {
      // check for primitive array types because they
      // unfortunately cannot be cast to Object[]
      if (o instanceof boolean[]) {
        booleanArrayAppend(sbuf, (boolean[]) o);
      } else if (o instanceof byte[]) {
        byteArrayAppend(sbuf, (byte[]) o);
      } else if (o instanceof char[]) {
        charArrayAppend(sbuf, (char[]) o);
      } else if (o instanceof short[]) {
        shortArrayAppend(sbuf, (short[]) o);
      } else if (o instanceof int[]) {
        intArrayAppend(sbuf, (int[]) o);
      } else if (o instanceof long[]) {
        longArrayAppend(sbuf, (long[]) o);
      } else if (o instanceof float[]) {
        floatArrayAppend(sbuf, (float[]) o);
      } else if (o instanceof double[]) {
        doubleArrayAppend(sbuf, (double[]) o);
      } else {
        objectArrayAppend(sbuf, (Object[]) o, seenMap);
      }
    }
632154
@Override
  public PathImpl schemeWalk(String userPath,
                         Map<String,Object> attributes,
                         String filePath,
                         int offset)
  {
    int length = filePath.length();

    if (length <= offset || filePath.charAt(offset) != '(')
      return super.schemeWalk(userPath, attributes, filePath, offset);

    MergePath mergePath = createMergePath();
    mergePath.setUserPath(userPath);

    int head = ++offset;
    int tail = head;
    while (tail < length) {
      int ch = filePath.charAt(tail);

      if (ch == ')') {
        if (head + 1 != tail) {
          String subPath = filePath.substring(head, tail);

          if (subPath.startsWith("(") && subPath.endsWith(")"))
            subPath = subPath.substring(1, subPath.length() - 1);

          mergePath.addMergePath(VfsOld.lookup(subPath));
        }

        if (tail + 1 == length)
          return mergePath;
        else
          return mergePath.fsWalk(userPath, attributes, filePath.substring(tail + 1));
      }
      else if (ch == ';') {
        String subPath = filePath.substring(head, tail);

        if (subPath.startsWith("(") && subPath.endsWith(")"))
          subPath = subPath.substring(1, subPath.length() - 1);

        mergePath.addMergePath(VfsOld.lookup(subPath));

        head = ++tail;
      }
      else if (ch == '(') {
        int depth = 1;

        for (tail++; tail < length; tail++) {
          if (filePath.charAt(tail) == '(')
            depth++;
          else if (filePath.charAt(tail) == ')') {
            tail++;
            depth--;
            if (depth == 0)
              break;
          }
        }

        if (depth != 0)
          return new NotFoundPath(getSchemeMap(), filePath);
      }
      else
        tail++;
    }

    return new NotFoundPath(getSchemeMap(), filePath);
  }
1192824
function deepFromEntries(parent, parentKey, path, value) {
  const key = path.shift()
  const current = isNaN(key) ? {} : []

  // TODO: Refactor that function to reduce code.
  if (!parent) {
    if (path.length === 0) {
      current[key] = value

      return current
    }

    current[key] = deepFromEntries(current[key], key, path, value)

    return current
  }

  if (isPlainObject(parent) || isArray(parent)) {
    if (path.length === 0) {
      parent[key] = value

      return parent
    }

    parent[key] = deepFromEntries(parent[key], key, path, value)

    return parent
  }

  if (path.length === 0) {
    current[key] = value

    return current
  }

  current[key] = deepFromEntries(parent[key], key, path, value)

  return current
}
1147142
function(inDir, outDir, relativePath, newCache) {
    var ext = this._matchingFileExtension(relativePath);
    var moduleName = relativePath.slice(0, relativePath.length - (ext.length + 1));
    var fullInputPath = path.join(inDir, relativePath);
    var fullOutputPath = path.join(outDir, moduleName + '.' + this.targetExtension);

    var entry = this._transpileThroughCache(
      moduleName,
      fs.readFileSync(fullInputPath, 'utf-8'),
      newCache
    );

    mkdirp.sync(path.dirname(fullOutputPath));
    fs.writeFileSync(fullOutputPath, entry.output);
  }