How to use the google-closure-deps.depGraph.GoogRequire function in google-closure-deps

it("loads deps of closure-library from the deps.js", async () => {
      const closureLib1 = path.resolve(fixturesBaseDir, "closure-lib1");
      const deps = await getClosureLibraryDependencies(closureLib1);
      deps.sort((a, b) => a.path.localeCompare(b.path));
      assertDependenciesEqual(deps, [
        new depGraph.Dependency(
          depGraph.DependencyType.CLOSURE_PROVIDE,
          `${closureLib1}/closure/goog/a11y/aria/aria.js`,
          ["goog.a11y.aria"],
          [new depGraph.GoogRequire("goog"), new depGraph.GoogRequire("goog.a11y.aria.Role")]
        ),
        new depGraph.Dependency(
          depGraph.DependencyType.CLOSURE_MODULE,
          `${closureLib1}/closure/goog/collections/sets.js`,
          ["goog.collections.sets"],
          [new depGraph.GoogRequire("goog")],
          "es6"
        ),
      ]);
    });
  });

it("outputs SCRIPT type dep", async () => {
      const dep = new depGraph.Dependency(
        depGraph.DependencyType.SCRIPT,
        "/app/foo.js",
        [],
        [new depGraph.GoogRequire("goog.array")]
      );
      const text = await generateDepFileTextFromDeps([dep], "/closure/goog");
      assert.equal(text, "goog.addDependency('../../app/foo.js', [], ['goog.array'], {});\n");
      assert.equal(dep.type, depGraph.DependencyType.SCRIPT, "dep.type should not be changed");
    });
    it("does not output imported `goog`", async () => {

["esm"],
    [new depGraph.Es6Import("./foo.js"), new depGraph.GoogRequire("goog")],
    "es6"
  ),
  new depGraph.Dependency(
    depGraph.DependencyType.ES6_MODULE,
    `${variousModulesFixturesDir}/esm.js`,
    [],
    [new depGraph.Es6Import("./foo.js")],
    "es6"
  ),
  new depGraph.Dependency(
    depGraph.DependencyType.SCRIPT,
    `${variousModulesFixturesDir}/script.js`,
    [],
    [new depGraph.GoogRequire("goog"), new depGraph.GoogRequire("goog.array")]
  ),
] as const;

describe("DependencyParser()", () => {
  it("parses closure provide script", async () => {
    const actual = await parseDependency(path.join(variousModulesFixturesDir, "closureprovide.js"));
    assertDependencyEquals(actual, expectedVariousModulesDeps[1]);
  });
});

describe("DependencyParserWithWorkers()", () => {
  let parser: DependencyParserWithWorkers;
  beforeEach(() => {
    parser = new DependencyParserWithWorkers();
  });
  afterEach(() => {

restoreDepsJs,
  writeCachedDepsOnDisk,
} from "../src/gendeps";

const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);
const fixturesBaseDir = path.join(__dirname, "fixtures");

const variousModulesFixturesDir = path.join(fixturesBaseDir, "various-modules");
const variousModulesDepsJsPath = path.join(fixturesBaseDir, "various-modules-deps.js");
const expectedVariousModulesDeps = [
  new depGraph.Dependency(
    depGraph.DependencyType.CLOSURE_MODULE,
    `${variousModulesFixturesDir}/closuremodule.js`,
    ["closuremodule"],
    [new depGraph.GoogRequire("goog"), new depGraph.GoogRequire("goog.array")]
  ),
  new depGraph.Dependency(
    depGraph.DependencyType.CLOSURE_PROVIDE,
    `${variousModulesFixturesDir}/closureprovide.js`,
    ["closureprovide"],
    [new depGraph.GoogRequire("goog"), new depGraph.GoogRequire("goog.array")]
  ),
  new depGraph.Dependency(
    depGraph.DependencyType.ES6_MODULE,
    `${variousModulesFixturesDir}/esm-moduleid.js`,
    ["esm"],
    [new depGraph.Es6Import("./foo.js"), new depGraph.GoogRequire("goog")],
    "es6"
  ),
  new depGraph.Dependency(
    depGraph.DependencyType.ES6_MODULE,

dependencies.forEach(dep => {
    dep.setClosurePath(googBaseDir);
    if (dep.closureSymbols.length > 0 || dep.imports.find(i => i.isGoogRequire())) {
      const goog = new depGraph.GoogRequire("goog");
      goog.from = dep;
      dep.imports.push(goog);
    }
  });
}

const imports = depData.imports.map(i => {
      if (i.isEs6Import && !i.isGoogRequire) {
        return new depGraph.Es6Import(i.symOrPath);
      } else if (!i.isEs6Import && i.isGoogRequire) {
        return new depGraph.GoogRequire(i.symOrPath);
      } else {
        throw new TypeError(`Unexpected import: ${i}`);
      }
    });
    return new depGraph.Dependency(