clojurific 0.12.1 → 0.12.3

package/README.md

@@ -5,8 +5,9 @@ ClojureScript compiled to ES modules, bundled by Vite.
 [Clojurific](https://github.com/WhimsicalCode/clojurific) is a fork of
 ClojureScript whose `:module-format :esm` compiles every namespace to an ES
 module, leaving bundling, minification, npm packages and TypeScript to Vite,
-without the Google Closure Compiler. This package has the compiler, the `cljf`
-command, a Vite plugin with hot reloading, and a Karma adapter. It needs
+without the Google Closure Compiler. This package has the `cljf` command, a
+Vite plugin with hot reloading, and a Karma adapter; `cljf` gets the compiler,
+`com.whimsical/clojurific`, from Clojars. It needs
 Node.js 20 or later and Java 17 or later, not the Clojure CLI.
 
 Status: experimental. Versions are `0.<minor>.<release>`: `<minor>` is the

package/cljf/cli.js

@@ -42,9 +42,10 @@ function parse(argv) {
 
 function run(command, args) {
   const child = spawn(command, args, { stdio: 'inherit' });
+  // forwarded: only a terminal signals the JVM too (SIGINT), not kill, an IDE
+  // or a process supervisor; a second SIGINT is harmless
   for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-    // the terminal sends SIGINT to the JVM too, other signals are forwarded
-    process.on(signal, () => signal !== 'SIGINT' && child.kill(signal));
+    process.on(signal, () => child.kill(signal));
   }
   child.on('error', e => {
     console.error(`cljf: ${command}: ${e.message}`);

package/cljf/java.js

@@ -203,7 +203,8 @@ export async function setupJava({
   await fs.mkdir(dir, { recursive: true });
   const tmp = await fs.mkdtemp(path.join(dir, '.setup-'));
   try {
-    const archive = path.join(tmp, pkg.name);
+    // a name from the API, not a path
+    const archive = path.join(tmp, path.basename(pkg.name));
     try {
       await download(pkg.link, archive, { sha256: pkg.checksum, fetch });
     } catch (e) {

package/cljf/launcher.js

@@ -4,7 +4,7 @@
 // Classpaths are cached in the project's .cljf/cpcache, like the Clojure
 // CLI's .cpcache, until a deps.edn they were resolved from changes.
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -21,11 +21,18 @@ const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '
 
 export const version = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8')).version;
 
-// The compiler's sources: compiler/ in the npm package, the fork itself
-// (src/main/js is the package's root) when run from its repository
-export const compilerDir = existsSync(path.join(packageRoot, 'compiler', 'deps.edn'))
-  ? path.join(packageRoot, 'compiler')
-  : path.resolve(packageRoot, '../../..');
+// Whether this is the npm package, which has no-clojurescript/, rather than
+// the fork's repository (src/main/js is the package's root)
+const packaged = existsSync(path.join(packageRoot, 'no-clojurescript', 'deps.edn'));
+
+// The fork's repository, its compiler's sources, when run from it
+export const compilerDir = packaged ? null : path.resolve(packageRoot, '../../..');
+
+// The compiler: the npm package's version from Clojars (com.whimsical/clojurific
+// is released with the package), or the fork's sources
+export const compiler = packaged ? { ':mvn/version': version } : { ':local/root': compilerDir };
+
+const noClojureScript = path.join(packaged ? packageRoot : compilerDir, 'no-clojurescript');
 
 const log = line => process.stderr.write(`${line}\n`);
 
@@ -37,7 +44,7 @@ export function normalizeAliases(aliases = []) {
 
 function cacheKey(aliases) {
   return createHash('sha256')
-    .update(JSON.stringify({ version, compiler: compilerDir, aliases }))
+    .update(JSON.stringify({ version, compiler, aliases }))
     .digest('hex')
     .slice(0, 32);
 }
@@ -71,12 +78,14 @@ async function resolve({ project, aliases, java, cache, env, log }) {
     repository: env.CLJF_MAVEN_REPO || undefined,
     log,
   });
-  const input = `${cache}.resolve.edn`;
-  const output = `${cache}.resolve.json`;
+  // per process: another one may resolve the same classpath at the same time
+  const tmp = `${cache}.${process.pid}.${randomBytes(4).toString('hex')}`;
+  const input = `${tmp}.resolve.edn`;
+  const output = `${tmp}.resolve.json`;
   await fs.writeFile(input, edn({
     ':aliases': aliases,
-    ':compiler': { ':local/root': compilerDir },
-    ':no-clojurescript': { ':local/root': path.join(compilerDir, 'no-clojurescript') },
+    ':compiler': compiler,
+    ':no-clojurescript': { ':local/root': noClojureScript },
     ':output': output,
   }));
   log('cljf: resolving dependencies');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clojurific",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "ClojureScript compiled to ES modules, bundled by Vite",
   "license": "EPL-1.0",
   "repository": {
@@ -24,7 +24,7 @@
     "cljf/resolver/clojurific",
     "vite-plugin-cljs",
     "karma-esm",
-    "compiler"
+    "no-clojurescript"
   ],
   "engines": {
     "node": ">=20"

package/vite-plugin-cljs/index.js

@@ -7,7 +7,7 @@
 // TypeScript files they import.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
@@ -31,16 +31,51 @@ async function sourceNamespace(file) {
   return ns;
 }
 
-// The ClojureScript sources pages load with module scripts
-async function pageSources(pages, root) {
-  const sources = [];
-  for (const page of pages) {
-    const html = await fs.readFile(page, 'utf8');
-    for (const [, src] of html.matchAll(/<script\b[^>]*\bsrc\s*=\s*["']([^"'?#]+\.clj[sc])["'][^>]*>/gi)) {
-      sources.push(src.startsWith('/') ? path.join(root, src) : path.resolve(path.dirname(page), src));
+const SCRIPT_SRC = /<script\b[^>]*\bsrc\s*=\s*["']([^"']+)["']/gi;
+// import "x", import x from "x", export … from "x", import("x")
+const IMPORT = /(?:\bimport\s*(?:[\w$*{}\s,]+\bfrom\s*)?|\bexport\s*[\w$*{}\s,]+\bfrom\s*|\bimport\s*\(\s*)["']([^"']+)["']/g;
+const SCRIPT_FILE = /\.(?:[cm]?[jt]sx?)$/;
+// extensionless imports, as TypeScript projects write them
+const SCRIPT_SUFFIXES = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '/index.ts', '/index.js'];
+
+// The file a page's script or a module's import names: root-absolute or
+// relative paths, not packages or aliases, which the bundler resolves
+function importedFile(spec, from, root) {
+  const file = spec.replace(/[?#].*$/, '');
+  if (!file.startsWith('/') && !file.startsWith('.')) return null;
+  return file.startsWith('/') ? path.join(root, file) : path.resolve(path.dirname(from), file);
+}
+
+// The ClojureScript sources the entries (pages and JavaScript or TypeScript
+// modules) load: the pages' scripts and the modules' imports, followed through
+// the project's modules
+async function entrySources(entries, root) {
+  const sources = new Set();
+  const seen = new Set();
+  const queue = [...entries];
+  while (queue.length) {
+    const file = queue.shift();
+    if (seen.has(file) || file.includes(`${path.sep}node_modules${path.sep}`)) continue;
+    seen.add(file);
+    let code;
+    try {
+      code = await fs.readFile(file, 'utf8');
+    } catch (e) {
+      continue;
+    }
+    for (const [, spec] of code.matchAll(file.endsWith('.html') ? SCRIPT_SRC : IMPORT)) {
+      const target = importedFile(spec, file, root);
+      if (!target) continue;
+      if (SOURCE_FILE.test(target)) {
+        if (existsSync(target)) sources.add(target);
+      } else {
+        const module = SCRIPT_SUFFIXES.map(suffix => target + suffix)
+          .find(f => SCRIPT_FILE.test(f) && existsSync(f) && !statSync(f).isDirectory());
+        if (module) queue.push(module);
+      }
     }
   }
-  return [...new Set(sources)];
+  return [...sources];
 }
 
 // Whether address is this machine's
@@ -73,14 +108,20 @@ async function commonJSPackage(root) {
   }
 }
 
-// A Rollup input (a file, files or {name: file}) as {name: absolute file}
+// A Rollup input (a file, files or {name: file}) as {name: absolute file},
+// files named by their path in the root without the extension, so pages with
+// the same file name in different directories (about/index.html) keep apart
 function inputObject(input, root) {
   if (!input) return {};
   if (typeof input === 'object' && !Array.isArray(input)) {
     return Object.fromEntries(Object.entries(input).map(([name, file]) => [name, path.resolve(root, file)]));
   }
-  return Object.fromEntries([].concat(input).map(file =>
-    [path.basename(file, path.extname(file)), path.resolve(root, file)]));
+  return Object.fromEntries([].concat(input).map(file => {
+    const absolute = path.resolve(root, file);
+    const relative = path.relative(root, absolute);
+    const name = relative.startsWith('..') || path.isAbsolute(relative) ? path.basename(absolute) : relative;
+    return [name.slice(0, name.length - path.extname(name).length).split(path.sep).join('/'), absolute];
+  }));
 }
 
 function ednString(s) {
@@ -315,6 +356,13 @@ export default function cljs(options) {
     return (compiled ? path.relative(outputDir, file) : path.relative(cwd, file)).split(path.sep).join('/');
   }
 
+  // Whether a ClojureScript source may be served: in Vite's root or
+  // server.fs.allow
+  function servedSource(file) {
+    const dirs = [config.root, ...(config.server?.fs?.allow ?? [])].map(dir => path.resolve(dir));
+    return SOURCE_FILE.test(file) && dirs.some(dir => file.startsWith(dir + path.sep));
+  }
+
   // The compiled module of a ClojureScript source file: its namespace's in the
   // build info, or its munged name
   async function compiledModule(file) {
@@ -325,7 +373,8 @@ export default function cljs(options) {
       `${ns.split('.').map(part => part.replace(/-/g, '_')).join('/')}.js`;
     const module = path.join(outputDir, relative);
     if (!existsSync(module)) {
-      throw new Error(`${ns} (${file}) isn't compiled: load it with a page's script, or add it to :main`);
+      throw new Error(`${ns} (${file}) isn't compiled: load it from a page's script or a module the pages ` +
+        'import (through relative or root-absolute imports, restarting Vite after adding it), or add it to :main');
     }
     return module;
   }
@@ -372,8 +421,8 @@ export default function cljs(options) {
       // the project's page, an input of builds and the dev server's /
       const indexHtml = existsSync(path.join(root, 'index.html')) ? path.join(root, 'index.html') : null;
       const userInput = userConfig.build?.rolldownOptions?.input ?? userConfig.build?.rollupOptions?.input;
-      const pages = Object.values(inputObject(userInput ?? indexHtml, root)).filter(f => f.endsWith('.html'));
-      pageNamespaces = await Promise.all((await pageSources(pages, root)).map(sourceNamespace));
+      const entries = Object.values(inputObject(userInput ?? indexHtml, root));
+      pageNamespaces = await Promise.all((await entrySources(entries, root)).map(sourceNamespace));
       if (env.command === 'build' && !env.isPreview) {
         const start = Date.now();
         if (userConfig.build?.watch) {
@@ -452,14 +501,17 @@ export default function cljs(options) {
       // A ClojureScript source: its compiled module, as a module importing it
       // when serving, which a page loading it by its source's URL and the
       // modules importing it by its own share
-      const file = source.split('?')[0];
+      const file = source.split(/[?#]/)[0];
       if (SOURCE_FILE.test(file) && !source.startsWith('\0')) {
+        // URLs are root-relative, files are only served from the project
         const candidates = [
-          ...(path.isAbsolute(file) ? [file] : []),
           ...(file.startsWith('/') ? [path.join(root, file)] : []),
-          ...(importer && !importer.startsWith('\0') ? [path.resolve(path.dirname(importer.split('?')[0]), file)] : []),
+          ...(importer && !importer.startsWith('\0') && !file.startsWith('/')
+            ? [path.resolve(path.dirname(importer.split('?')[0]), file)]
+            : []),
+          ...(path.isAbsolute(file) ? [file] : []),
         ];
-        const found = candidates.find(f => existsSync(f));
+        const found = candidates.find(f => servedSource(f) && existsSync(f));
         if (!found) return null;
         return config.command === 'build' ? compiledModule(found) : '\0' + SOURCE + found;
       }
@@ -479,7 +531,9 @@ export default function cljs(options) {
 
     async load(id) {
       if (id.startsWith('\0' + SOURCE)) {
-        const module = await compiledModule(id.slice(SOURCE.length + 1));
+        const file = id.slice(SOURCE.length + 1);
+        if (!servedSource(file)) this.error(`${file} is outside the project`);
+        const module = await compiledModule(file);
         return `import ${JSON.stringify(module)};\nexport * from ${JSON.stringify(module)};\n`;
       }
       // compiled namespaces with their source maps, to the ClojureScript sources
@@ -604,9 +658,10 @@ export default function cljs(options) {
       async handler(html, { filename }) {
         if (config.command !== 'serve') return html;
         const replacements = await Promise.all(
-          [...html.matchAll(/(<script\b[^>]*\bsrc\s*=\s*["'])([^"'?#]+\.clj[sc])(["'])/gi)].map(async match => {
+          // with a query or fragment, which the compiled module's URL keeps
+          [...html.matchAll(/(<script\b[^>]*\bsrc\s*=\s*["'])([^"'?#]+\.clj[sc])([?#][^"']*)?(["'])/gi)].map(async match => {
             const file = match[2].startsWith('/') ? path.join(config.root, match[2]) : path.resolve(path.dirname(filename), match[2]);
-            return [match[0], match[1] + devUrl(await compiledModule(file)) + match[3]];
+            return [match[0], match[1] + devUrl(await compiledModule(file)) + (match[3] ?? '') + match[4]];
           }));
         return replacements.reduce((result, [from, to]) => result.replace(from, to), html);
       },

package/compiler/deps.edn

@@ -1,9 +0,0 @@
-{:paths ["src/main/clojure" "src/main/cljs"],
- :deps
- {com.cognitect/transit-java {:mvn/version "1.0.362"},
-  org.clojure/clojure {:mvn/version "1.12.6"},
-  org.clojure/core.specs.alpha {:mvn/version "0.1.24"},
-  org.clojure/google-closure-library
-  {:mvn/version "0.0-20250515-f04e4c0e"},
-  org.clojure/spec.alpha {:mvn/version "0.1.143"},
-  org.clojure/tools.reader {:mvn/version "1.3.6"}}}

package/compiler/src/main/cljs/cljs/analyzer/passes/and_or.cljc

@@ -1,118 +0,0 @@
-;; Copyright (c) Rich Hickey. All rights reserved.
-;; The use and distribution terms for this software are covered by the
-;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
-;; which can be found in the file epl-v10.html at the root of this distribution.
-;; By using this software in any fashion, you are agreeing to be bound by
-;; the terms of this license.
-;; You must not remove this notice, or any other, from this software.
-
-(ns cljs.analyzer.passes.and-or
-  (:require [cljs.analyzer.passes :as passes]))
-
-(def simple-ops
-  #{:var :js-var :local :invoke :const :host-field :host-call :js :quote})
-
-(defn ->expr-env [ast]
-  (assoc-in ast [:env :context] :expr))
-
-(defn simple-op? [ast]
-  (contains? simple-ops (:op ast)))
-
-(defn simple-test-expr?
-  [{:keys [op] :as ast}]
-  (boolean
-    (and (simple-op? ast)
-         ('#{boolean seq}
-           (or (:tag ast)
-               (when (#{:local :var} op)
-                 (-> ast :info :tag)))))))
-
-(defn single-binding-let? [ast]
-  (and (= :let (:op ast))
-       (= 1 (count (-> ast :bindings)))))
-
-(defn no-statements? [let-ast]
-  (= [] (-> let-ast :body :statements)))
-
-(defn returns-if? [let-ast]
-  (= :if (-> let-ast :body :ret :op)))
-
-(defn simple-test-binding-let? [ast]
-  (and (single-binding-let? ast)
-       (no-statements? ast)
-       (simple-test-expr? (-> ast :bindings first :init))
-       (returns-if? ast)))
-
-(defn test=then? [if-ast]
-  ;; remove :env, if same, local will differ only by
-  ;; :context (:expr | :statement)
-  (= (dissoc (:test if-ast) :env)
-     (dissoc (:then if-ast) :env)))
-
-(defn test=else? [if-ast]
-  ;; remove :env, if same, local will differ only by
-  ;; :context (:expr | :statement)
-  (= (dissoc (:test if-ast) :env)
-     (dissoc (:else if-ast) :env)))
-
-(defn simple-and? [ast]
-  (and (simple-test-binding-let? ast)
-       (test=else? (-> ast :body :ret))))
-
-(defn simple-or? [ast]
-  (and (simple-test-binding-let? ast)
-       (test=then? (-> ast :body :ret))))
-
-(defn optimizable-and? [ast]
-  (and (simple-and? ast)
-       (simple-test-expr? (-> ast :body :ret :then))))
-
-(defn optimizable-or? [ast]
-  (and (simple-or? ast)
-       (simple-test-expr? (-> ast :body :ret :else))))
-
-(defn remove-loop-let [fn-ast local]
-  (update fn-ast :loop-lets
-    (fn [loop-lets]
-      (map
-        (fn [m]
-          (update m :params
-            (fn [xs] (remove #(= local (:name %)) xs))))
-        loop-lets))))
-
-(defn remove-local-pass [local]
-  (fn [env ast opts]
-    (cond-> (update-in ast [:env :locals] dissoc local)
-      (= :fn (:op ast)) (remove-loop-let local))))
-
-(defn optimize-and [ast]
-  (let [{:keys [init name]} (-> ast :bindings first)]
-    {:op :js
-     :env (:env ast)
-     :segs ["((" ") && (" "))"]
-     :args [init
-            (passes/walk
-              (->expr-env (-> ast :body :ret :then))
-              [(remove-local-pass name)])]
-     :form (:form ast)
-     :children [:args]
-     :tag 'boolean}))
-
-(defn optimize-or [ast]
-  (let [{:keys [init name]} (-> ast :bindings first)]
-    {:op :js
-     :env (:env ast)
-     :segs ["((" ") || (" "))"]
-     :args [init
-            (passes/walk
-              (->expr-env (-> ast :body :ret :else))
-              [(remove-local-pass name)])]
-     :form (:form ast)
-     :children [:args]
-     :tag 'boolean}))
-
-(defn optimize [env ast _]
-  (cond
-    (optimizable-and? ast) (optimize-and ast)
-    (optimizable-or? ast)  (optimize-or ast)
-    :else ast))

package/compiler/src/main/cljs/cljs/analyzer/passes/lite.cljc

@@ -1,32 +0,0 @@
-;; Copyright (c) Rich Hickey. All rights reserved.
-;; The use and distribution terms for this software are covered by the
-;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
-;; which can be found in the file epl-v10.html at the root of this distribution.
-;; By using this software in any fashion, you are agreeing to be bound by
-;; the terms of this license.
-;; You must not remove this notice, or any other, from this software.
-
-(ns cljs.analyzer.passes.lite
-  (:refer-clojure :exclude [var?]))
-
-(defn var? [ast]
-  (= :var (:op ast)))
-
-(def ctor->ctor-lite
-  '{cljs.core/vector cljs.core/vector-lite
-    cljs.core/vec    cljs.core/vec-lite})
-
-(defn update-var [{:keys [name] :as ast}]
-  (let [replacement (get ctor->ctor-lite name)]
-    (-> ast
-      (assoc :name replacement)
-      (assoc-in [:info :name] replacement))))
-
-(defn replace-var? [ast]
-  (and (var? ast)
-       (contains? ctor->ctor-lite (:name ast))))
-
-(defn use-lite-types
-  [env ast _]
-  (cond-> ast
-    (replace-var? ast) update-var))

package/compiler/src/main/cljs/cljs/analyzer/passes.cljc

@@ -1,32 +0,0 @@
-;; Copyright (c) Rich Hickey. All rights reserved.
-;; The use and distribution terms for this software are covered by the
-;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
-;; which can be found in the file epl-v10.html at the root of this distribution.
-;; By using this software in any fashion, you are agreeing to be bound by
-;; the terms of this license.
-;; You must not remove this notice, or any other, from this software.
-
-(ns cljs.analyzer.passes)
-
-(defn apply-passes
-  ([ast passes]
-   (apply-passes ast passes nil))
-  ([ast passes opts]
-   (reduce
-     (fn [ast pass]
-       (pass (:env ast) ast opts))
-     ast passes)))
-
-(defn walk
-  ([ast passes]
-   (walk ast passes nil))
-  ([ast passes opts]
-   (reduce
-     (fn [ast child-k]
-       (assoc ast
-         child-k
-         (let [child (get ast child-k)]
-           (if (vector? child)
-             (into [] (map #(walk % passes opts)) child)
-             (walk child passes opts)))))
-     (some-> ast (apply-passes passes opts)) (:children ast))))

package/compiler/src/main/cljs/cljs/bootstrap_nodejs.js

@@ -1,154 +0,0 @@
-// Copyright 2013 The Closure Library Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview A nodejs script for dynamically requiring Closure within
- * nodejs.
- *
- * Example of usage:
- * <code>
- * require('./bootstrap/nodejs')
- * goog.require('goog.ui.Component')
- * </code>
- *
- * This loads goog.ui.Component in the global scope.
- *
- * If you want to load custom libraries, you can require the custom deps file
- * directly. If your custom libraries introduce new globals, you may
- * need to run goog.nodeGlobalRequire to get them to load correctly.
- *
- * <code>
- * require('./path/to/my/deps.js')
- * goog.bootstrap.nodeJs.nodeGlobalRequire('./path/to/my/base.js')
- * goog.require('my.Class')
- * </code>
- *
- * @author nick@medium.com (Nick Santos)
- *
- * @nocompile
- */
-
-var fs        = require("fs");
-var vm        = require("vm");
-var path      = require("path");
-var CLJS_ROOT = ".";
-
-
-/**
- * The goog namespace in the global scope.
- */
-global.goog = {};
-
-
-/**
- * Imports a script using Node's require() API.
- *
- * @param {string} src The script source.
- * @return {boolean} True if the script was imported, false otherwise.
- */
-global.CLOSURE_IMPORT_SCRIPT = function(src, opt_sourceText) {
-    // if CLJS_ROOT has been rewritten (by REPLs) need to compute require path
-    // so we can delete the old entry from the Node.js require cache
-    if(CLJS_ROOT !== ".") {
-        var cached = null;
-        if(src.substring(0, 2) == "..") {
-            cached = path.join(CLJS_ROOT, src.substring(3));
-        } else {
-            cached = path.join(CLJS_ROOT, "goog", src);
-        }
-        if(require.cache[cached]) delete require.cache[cached];
-    }
-
-    // Sources are always expressed relative to closure's base.js, but
-    // require() is always relative to the current source.
-    if (opt_sourceText === undefined) {
-        var flags = null;
-        if (goog.debugLoader_) {
-            var dep = goog.debugLoader_.dependencies_[src];
-            if (dep) {
-                flags = dep.loadFlags;
-            }
-        } else {
-            flags = goog.dependencies_.loadFlags[src];
-        }
-        if (flags && flags["foreign-lib"]) {
-            nodeGlobalRequire(path.resolve(__dirname, "..", src));
-        } else {
-            require(path.join(".", "..", src));
-        }
-    } else {
-        eval(opt_sourceText);
-    }
-    return true;
-};
-
-
-/**
- * Loads a file when using Closure's goog.require() API with goog.modules.
- *
- * @param {string} src The file source.
- * @return {string} The file contents.
- */
-global.CLOSURE_LOAD_FILE_SYNC = function(src) {
-    return fs.readFileSync(
-      path.resolve(__dirname, "..", src), {encoding: "utf-8"});
-};
-
-
-// Declared here so it can be used to require base.js
-function nodeGlobalRequire(file) {
-    var _module  = global.module,
-        _exports = global.exports,
-        exportedRequire = false;
-
-    // to circumvent Node.js environment detection in bundled libraries
-    global.module = undefined;
-    global.exports = undefined;
-
-    // to allow requires of Node.js libraries (i.e. platform libs) that
-    // couldn't be bundled for some reason
-    if(global.require == undefined) {
-        exportedRequire = true;
-        global.require = require;
-    }
-
-    vm.runInThisContext.call(global, fs.readFileSync(file), file);
-
-    global.exports = _exports;
-    global.module = _module;
-
-    if(exportedRequire) {
-        global.require = undefined;
-    }
-}
-
-
-// Load Closure's base.js into memory.  It is assumed base.js is in the
-// directory above this directory given this script's location in
-// bootstrap/nodejs.js.
-nodeGlobalRequire(path.resolve(__dirname, "..", "base.js"));
-
-
-/**
- * Bootstraps a file into the global scope.
- *
- * This is strictly for cases where normal require() won't work,
- * because the file declares global symbols with 'var' that need to
- * be added to the global scope.
- * @suppress {missingProvide}
- *
- * @param {string} file The path to the file.
- */
-goog.nodeGlobalRequire = nodeGlobalRequire;
-