goog.module('search.urlHistory.urlHistoryService');

goog.module('foo.bar');   // 'foo.bar.qux' would be fine, though
goog.module('foo.bar.baz');

goog.module('my.test.helpers');
goog.module.declareLegacyNamespace();
goog.setTestOnly();

const /** !Array<number> */ exportedArray = [1, 2, 3];
 
const /** !Array<number> */ moduleLocalArray = [4, 5, 6];
 
/** @return {number} */
function moduleLocalFunction() {
  return moduleLocalArray.length;
}
 
/** @return {number} */
function exportedFunction() {
  return moduleLocalFunction() * 2;
}
 
exports = {exportedArray, exportedFunction};

/** @const {number} */
exports.CONSTANT_ONE = 1;
 
/** @const {string} */
exports.CONSTANT_TWO = 'Another constant';

/** @const */
exports = {exportedFunction};

exports = FancyClass;

import './sideeffects.js';
 
import * as goog from '../closure/goog/goog.js';
import * as parent from '../parent.js';
 
import {name} from './sibling.js';

import '../directory/file';

import '../directory/file.js';

// Imports have the same path, but since it doesn't align it can be hard to see.
import {short} from './long/path/to/a/file.js';
import {aLongNameThatBreaksAlignment} from './long/path/to/a/file.js';

import * as fileOne from '../file-one.js';
import * as fileTwo from '../file_two.js';
import * as fileThree from '../filethree.js';

import * as libString from './lib/string.js';
import * as math from './math/math.js';
import * as vectorMath from './vector/math.js';

import MyClass from '../my-class.js';
import myFunction from '../my_function.js';
import SOME_CONSTANT from '../someconstant.js';

import * as bigAnimals from './biganimals.js';
import * as domesticatedAnimals from './domesticatedanimals.js';
 
new bigAnimals.Cat();
new domesticatedAnimals.Cat();

import {Cat as BigCat} from './biganimals.js';
import {Cat as DomesticatedCat} from './domesticatedanimals.js';
 
new BigCat();
new DomesticatedCat();

// Do not use default exports:
export default class Foo { ... } // BAD!

// Use named exports:
export class Foo { ... }

// Alternate style named exports:
class Foo { ... }
 
export {Foo};

// Bad: both foo and mutateFoo are exported and mutated.
export let /** number */ foo = 0;
 
/**
 * Mutates foo.
 */
export function mutateFoo() {
  ++foo;
}
 
/**
 * @param {function(number): number} newMutateFoo
 */
export function setMutateFoo(newMutateFoo) {
  // Exported classes and functions can be mutated!
  mutateFoo = () => {
    foo = newMutateFoo(foo);
  };
}

// Good: Rather than export the mutable variables foo and mutateFoo directly,
// instead make them module scoped and export a getter for foo and a wrapper for
// mutateFooFunc.
let /** number */ foo = 0;
let /** function(number): number */ mutateFooFunc = (foo) => foo + 1;
 
/** @return {number} */
export function getFoo() {
  return foo;
}
 
export function mutateFoo() {
  foo = mutateFooFunc(foo);
}
 
/** @param {function(number): number} mutateFoo */
export function setMutateFoo(mutateFoo) {
  mutateFooFunc = mutateFoo;
}

export {specificName} from './other.js';
export * from './another.js';

// a.js
import './b.js';

// b.js
import './a.js';
 
// `export from` can cause circular dependencies too!
export {x} from './c.js';

// c.js
import './b.js';
 
export let x;

import * as goog from '../closure/goog/goog.js';
 
const {compute} = goog.require('a.name');
 
export const CONSTANT = compute();

import * as goog from '../closure/goog/goog.js';
import * as anEsModule from './anEsModule.js';
 
const GoogPromise = goog.require('goog.Promise');
const myNamespace = goog.require('my.namespace');

import * as goog from '../closure/goog.js';
 
goog.declareModuleId('my.esm');
 
export class Class {};

// Standard alias style.
const asserts = goog.require('goog.asserts');
// Namespace-based alias used to disambiguate.
const testingAsserts = goog.require('goog.testing.asserts');
// Standard destructuring into aliases.
const {MyClass} = goog.require('some.package');
const {MyType} = goog.requireType('other.package');
const {clear, clone} = goog.require('goog.array');
const {Rgb} = goog.require('goog.color');
// Namespace-based destructuring into aliases used to disambiguate.
const {MyClass: NsMyClass} = goog.require('other.ns');
const {SomeType: FooSomeType} = goog.requireType('foo.types');
const {clear: objectClear, clone: objectClone} = goog.require('goog.object');
// Namespace-based destructuring into aliases used to prevent masking native type.
const {Element: RendererElement} = goog.require('web.renderer');
// Out of sequence namespace-based aliases used to improve readability.
// Also, require lines longer than 80 columns must not be wrapped.
const {SomeDataStructure: SomeDataStructureModel} = goog.requireType('identical.package.identifiers.models');
const {SomeDataStructure: SomeDataStructureProto} = goog.require('proto.identical.package.identifiers');
// goog.require without an alias in order to trigger side effects.
/** @suppress {extraRequire} Initializes MyFramework. */
goog.require('my.framework.initialization');

// Some legacy code uses a "default export" style to export a single class, enum,
// record type, etc. Do not use this pattern in new JS.
// When using a "default export", prefer destructuring into aliases.
const MyClass = goog.require('some.package.MyClass');
const MyType = goog.requireType('some.package.MyType');

// If necessary to disambiguate, prefer PackageClass over SomeClass as it is
// closer to the format of the module name.
const SomeClass = goog.require('some.package.Class');

// Extra terms must come from the namespace.
const MyClassForBizzing = goog.require('some.package.MyClass');
// Alias must include the entire final namespace component.
const MyClass = goog.require('some.package.MyClassForBizzing');
// Alias must not mask native type (should be `const JspbMap` here).
const Map = goog.require('jspb.Map');
// Don't break goog.require lines over 80 columns.
const SomeDataStructure =
    goog.require('proto.identical.package.identifiers.SomeDataStructure');
// Alias must be based on the namespace.
const randomName = goog.require('something.else');
// Missing a space after the colon.
const {Foo:FooProto} = goog.require('some.package.proto.Foo');
// goog.requireType without an alias.
goog.requireType('some.package.with.a.Type');
 
 
/**
 * @param {!some.unimported.Dependency} param All external types used in JSDoc
 *     annotations must be goog.require'd, unless declared in externs.
 */
function someFunction(param) {
  // goog.require lines must be at the top level before any other code.
  const alias = goog.require('my.long.name.alias');
  // ...
}