Exported functions
348716
function buildConcatIfPresent(b, path, concatArgs) {
  let args = concatArgs.map((p) => typeof p === 'string' ? b.string(p) : p);
  return buildConditional(b, [path, b.sexpr(b.path('concat'), args)]);
}
842409
public static void export(JavaScriptObject o, String name, Function f) {
    prop(o, name, (Object)(f != null ? wrapFunction(f) : null));
  }
691502
public static void export(String name, Function f) {
    export(GQuery.window, name, f);
  }
70333
function exports(_selection) {
            _selection.each(function(_data) {
                chartWidth = width - margin.left - margin.right;
                chartHeight = height - margin.top - margin.bottom;
                data = cleanData(_data);

                buildLayout();
                buildColorScale();
                buildShape();
                buildSVG(this);
                drawSlices();
                initTooltip();

                if (highlightedSliceId) {
                    initHighlightSlice();
                }
                if (isEmpty && emptyDataConfig.showEmptySlice) {
                    drawEmptySlice();
                }
            });
        }
1156845
function exports(_selection) {
            _selection.each(function (_data) {
                data = cleanData(_data);

                chartWidth = width - margin.left - margin.right;
                chartHeight = height - margin.top - margin.bottom;

                buildScales();
                buildSVG(this);
                drawDayLabels();
                drawHourLabels();
                drawBoxes();
            });
        }
870261
function exportDeclarations() {

    var docs = getJSONDocs();
    var sugarjs = getDeclaredNamespace('sugarjs');

    var extendedInterfaces = [], nativeNames = [];

    function getNamespaceTypesMerged(num, suffixVal, join, supplementary) {
      var types = nativeNames.concat(supplementary || []);
      var indent = ' '.repeat(num);
      return types.map(function(type) {
        var suffix = typeof suffixVal === 'function' ? suffixVal(type) : suffixVal;
        return type + suffix;
      }).join(' ' + join + '\n' + indent);
    }

    function getChainableNameExternal(type) {
      return '.Chainable' + getChainableBaseGenerics(type, CHAINABLE_RAW_TYPE, 'any');
    }

    function writeDeclarations(filename, declarations) {
      declarations = compact(declarations);
      var hasNoDeclarations = declarations.every(function(dec) {
        return /^\/\//.test(dec);
      });
      if (hasNoDeclarations) {
        return;
      }
      writeFile(path.join(basePath || '', filename), compact(declarations).join('\n\n'));
    }

    sugarjs.interfaces.push(getLocaleInterface(docs.namespaces));

    // Sort namespaces for Sugar to come before SugarNamespace
    // as it has ExtendOptions which are defined first.
    docs.namespaces.sort(collateNamespaces);

    docs.namespaces.forEach(function(namespace) {

      function addExtras(module) {
        addCallbackTypes(module);
        addOptionsInterfaces(module);
      }

      function addCallbackTypes(module) {

        // If the param has multiple types, then move callbacks into the
        // module as named types. Only do this if there are multiple
        // types, otherwise the callback signature can be inlined into
        // the method declaration.
        function getAlternateTypes(method) {
          var types = [];

          function process(arr) {
            if (arr) {
              arr.forEach(function(obj) {
                if (obj.type) {
                  var split = obj.type.split('|');
                  if (split.length > 1) {
                    types = types.concat(split);
                  }
                }
              });
            }
          }

          process(method.params);
          process(method.options);

          return types;
        }

        function addModuleCallbackType(method, callback) {
          var typeExists = module.types.some(function(t) {
            return t.name === callback.name;
          });
          if (!typeExists) {
            var signature = getCallbackSignature(callback, method, namespace);
            if (method.generics) {
              moduleCallbackGenerics[namespace.name + ':' + callback.name] = method.generics;
            }
            module.types.push({
              name: callback.name,
              generics: getGenericSource(callback.generics),
              type: signature
            });
          }
        }

        namespace.methods.forEach(function(method) {
          if (!method.callbacks || methodIsBlacklisted(namespace.name, method)) {
            return;
          }
          getAlternateTypes(method).forEach(function(type) {
            if (type.match(/Fn$/)) {
              var callback = findMethodCallbackByName(method, type);
              addModuleCallbackType(method, callback);
            }
          });
        });

      }

      function addOptionsInterfaces(module) {
        namespace.methods.forEach(function(method) {
          if (!method.options || methodIsBlacklisted(namespace.name, method)) {
            return;
          }

          var params = method.params;
          (method.signatures || []).forEach(function(signature) {
            params = params.concat(signature);
          })

          var optionsParam = params.find(function(param) {
            return param.type.match(/Options$/);
          });

          var optionsGenerics = [];

          var src = method.options.map(function(option) {
            var types = option.type.split('|');
            types = types.map(function(type) {
              if (type.match(/Fn$/)) {
                var callback = findMethodCallbackByName(method, type);
                if (types.length === 1 && type.match(/Fn$/)) {
                  // Inline a callback delcaration
                  type = getCallbackSignature(callback, method, namespace);
                } else {
                  // Refer to callback externally
                  type += getGenericSource(moduleCallbackGenerics[namespace.name + ':' + callback.name]);
                }
                optionsGenerics = optionsGenerics.concat(callback.generics);
              }
              return type;
            });
            return option.name + (option.required ? '' : '?') + ': ' + types.join('|') + ';';
          }).join('\n');

          // Store references to the namespaces that option interfaces exist in
          // so that we can reference them externally later.
          if (!namespace.name.match(/^Sugar/)) {
            optionInterfaceNamespaces[optionsParam.type] = namespace.name;
          }

          moduleOptionsGenerics[namespace.name + ':' + optionsParam.type] = optionsGenerics;
          var name = optionsParam.type + getGenericSource(optionsGenerics);
          module.interfaces.push(getInterfaceSource(name, src));
        });
      }

      function getCallbackSignature(callback, method, namespace) {
        var genericsLength = method.generic && method.generics.length || 0, gen;
        var params = getParams(callback.params, method, namespace);
        var returns = callback.returns ? getType(callback.returns, method) : 'void';
        // Slightly convoluted way of getting generics for the callback by
        // subtracting method generics from what they were previously.
        callback.generics = method.generics.slice(genericsLength);
        return '(' + params + ') => ' + returns;
      }

      function findMethodCallbackByName(method, name) {
        return method.callbacks.find(function(callback) {
          return callback.name === name;
        });
      }


      // Exclude polyfills
      namespace.methods = namespace.methods.filter(function(method) {
        return !method.module.match(/ES[5-7]/);
      });

      // Unpack sets like "[unit]FromNow"
      namespace.methods = unpackMethodSets(namespace.methods);

      if (namespace.name === 'Sugar') {
        addExtras(sugarjs);
        sugarjs.interfaces.push(getSugarInterface(namespace, docs.namespaces));
      } else if (namespace.name === 'SugarNamespace') {
        // The generic "SugarNamespace" interface is required for the
        // "createNamespace" method that needs to return an as-yet undefined
        // type. For existing namespaces, the methods here will instead be
        // mixed into each individual interface. This is required, as each
        // namespace returns a reference to itself, and so (it would appear)
        // cannot use extend.
        addExtras(sugarjs);
        sugarjs.interfaces.push(getSugarNamespaceInterface(namespace));
      } else if (namespace.name === 'Range') {
        sugarjs.interfaces.push(getRangeInterface(namespace));
      } else {
        var module = getDeclaredNamespace(namespace.name);
        addExtras(module);
        module.interfaces.push(getConstructorInterface(namespace, module));
        module.interfaces.push(getChainableBaseInterface(namespace));


        // Export extended interfaces unless opting out.
        if (args['extended-mode'] !== false) {
          extendedInterfaces.push(getExtendedConstructorInterface(namespace));

          // Note: due to Typescript quirkiness about incompatible interfaces,
          // Object.prototype mode cannot be supported here for now.
          if (namespace.name !== 'Object') {
            extendedInterfaces.push(getExtendedInstanceInterface(namespace));
          }
        }

        sugarjs.namespaces.push(getDeclaredNamespaceSource(module));
        nativeNames.push(namespace.name);
      }

    });

    var wrappedGeneric = getGenericSource(CHAINABLE_RAW_TYPE);
    sugarjs.types.push({
      name: 'SugarDefaultChainable' + wrappedGeneric,
      type: getNamespaceTypesMerged(39, getChainableNameExternal, '&'),
    });

    sugarjs.types.push({
      name: 'NativeConstructor',
      type: getNamespaceTypesMerged(25, 'Constructor', '|', ['Boolean', 'Error']),
    });


    var baseDeclarations = [];
    baseDeclarations.push(TS_LICENSE);
    baseDeclarations.push(getDeclaredNamespaceSource(sugarjs, true));
    baseDeclarations.push(getDeclaredModuleSource());
    baseDeclarations.push('declare var Sugar: sugarjs.Sugar;');

    var extendedDeclarations = [];
    extendedDeclarations.push(TS_EXTENDED_LICENSE);
    extendedDeclarations.push('/// <reference path="sugar.d.ts" />');
    extendedDeclarations.push(getInterfaceBlocks(extendedInterfaces));

    writeDeclarations('sugar.d.ts', baseDeclarations);
    writeDeclarations('sugar-extended.d.ts', extendedDeclarations);
  }
589618
function ExportNamedDeclaration(node, parent, scope) {
    var nodes = [];
    build(node, nodes, scope);
    if (!nodes.length) return;

    if (node.specifiers.length >= 1) {
      nodes.push(node);
    }

    return nodes;
  }
1271413
function exports(_selection){
            _selection.each(function(_data){
                chartWidth = width - margin.left - margin.right;
                chartHeight = height - margin.top - margin.bottom;
                data = cleanData(cloneData(_data));

                buildScales();
                buildAxis();
                buildSVG(this);
                buildGradient();
                buildBrush();
                drawArea();
                drawAxis();
                drawBrush();
                drawHandles();
            });
        }
982339
function getExports(fullpath, { initializer, call, inject }, pathName) {
  let exports = utils.loadFile(fullpath);
  // process exports as you like
  if (initializer) {
    exports = initializer(exports, { path: fullpath, pathName });
  }

  // return exports when it's a class or generator
  //
  // module.exports = class Service {};
  // or
  // module.exports = function*() {}
  if (is.class(exports) || is.generatorFunction(exports) || is.asyncFunction(exports)) {
    return exports;
  }

  // return exports after call when it's a function
  //
  // module.exports = function(app) {
  //   return {};
  // }
  if (call && is.function(exports)) {
    exports = exports(inject);
    if (exports != null) {
      return exports;
    }
  }

  // return exports what is
  return exports;
}
396732
function extendExportSymbols(target, source, lookupTable, exportNode) {
            for (var id in source) {
                if (id !== "default" && !target[id]) {
                    target[id] = source[id];
                    if (lookupTable && exportNode) {
                        lookupTable[id] = {
                            specifierText: ts.getTextOfNode(exportNode.moduleSpecifier)
                        };
                    }
                }
                else if (lookupTable && exportNode && id !== "default" && target[id] && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
                    if (!lookupTable[id].exportsWithDuplicate) {
                        lookupTable[id].exportsWithDuplicate = [exportNode];
                    }
                    else {
                        lookupTable[id].exportsWithDuplicate.push(exportNode);
                    }
                }
            }
        }
1334937
function saveNameToExportMap(index, def, exportsMap) {
    if (exportsMap) {
        if (def.exportAs)
            exportsMap[def.exportAs] = index;
        if (def.template)
            exportsMap[''] = index;
    }
}
738236
function ExportDeclaration(node, parent, scope, formatter) {
  formatter.hasLocalExports = true;

  var source = node.source ? node.source.value : null;
  var exports = formatter.metadata.exports;

  // export function foo() {}
  // export var foo = "bar";
  var declar = this.get("declaration");
  if (declar.isStatement()) {
    var bindings = declar.getBindingIdentifiers();

    for (var name in bindings) {
      var binding = bindings[name];
      formatter._addExport(name, binding);

      exports.exported.push(name);
      exports.specifiers.push({
        kind: "local",
        local: name,
        exported: this.isExportDefaultDeclaration() ? "default" : name
      });
    }
  }

  if (this.isExportNamedDeclaration() && node.specifiers) {
    var _arr2 = node.specifiers;

    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
      var specifier = _arr2[_i2];
      var exported = specifier.exported.name;
      exports.exported.push(exported);

      // export foo from "bar";
      if (t.isExportDefaultSpecifier(specifier)) {
        exports.specifiers.push({
          kind: "external",
          local: exported,
          exported: exported,
          source: source
        });
      }

      // export * as foo from "bar";
      if (t.isExportNamespaceSpecifier(specifier)) {
        exports.specifiers.push({
          kind: "external-namespace",
          exported: exported,
          source: source
        });
      }

      var local = specifier.local;
      if (!local) continue;

      formatter._addExport(local.name, specifier.exported);

      // export { foo } from "bar";
      // export { foo as bar } from "bar";
      if (source) {
        exports.specifiers.push({
          kind: "external",
          local: local.name,
          exported: exported,
          source: source
        });
      }

      // export { foo };
      // export { foo as bar };
      if (!source) {
        exports.specifiers.push({
          kind: "local",
          local: local.name,
          exported: exported
        });
      }
    }
  }

  // export * from "bar";
  if (this.isExportAllDeclaration()) {
    exports.specifiers.push({
      kind: "external-all",
      source: source
    });
  }

  if (!t.isExportDefaultDeclaration(node) && !declar.isTypeAlias()) {
    var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
    if (!onlyDefault) {
      formatter.hasNonDefaultExports = true;
    }
  }
}
1229007
function exportPkg(pkg, isChild, pkgName, externImports) {
    var keys = Object.keys(pkg);
    var imports = externImports || [];

    var topLevels = [];
    var children = keys.map(function (name) {
        if (isString(pkg[name])) {
            var className = name.substring(0, name.indexOf('$'));
            if (topLevelClasses.find(function (item) {
                return pkg[name].indexOf(item) >= 0;
            })) {
                topLevels.push(name);
            }
            // a class, not a packagge
            imports.push(pkg[name]);
            if (pkgName) {
                // export as a child class in package
                // indentation + (key : value)
                return (isChild ? '        '  : '    ') + className + ' : ' + name;
            }
            else {
                // export as a class at root level
                return `export { ${name} as ${className} };`;
            }
        }
        else {
            // export as a child package
            return exportPkg(pkg[name], pkgName && true, name, imports);
        }
    });

    var importCode = (externImports ? '' : imports.join('\n') + '\n\n');
    var exportCode;
    if (pkgName) {
        if (isChild) {
            // export as a grand-child package
            exportCode = `    ${pkgName} : {\n${children.join(',\n')}\n    }`;
        }
        else {
            // export as a package at root level
            exportCode = `\nvar ${pkgName} = {\n${children.join(',\n')}\n};\nexport { ${pkgName} };\n`;
        }
    }
    else {
        // export child classes
        exportCode = children.join('\n');
    }

    topLevels.forEach(function (name) {
        var className = name.substring(0, name.indexOf('$'));
        exportCode += `export { ${name} as ${className} };\n`;
    });

    return importCode  + exportCode;
}
213277
function main() {
		var el;

		el = document.querySelector( 'title' );
		cleanTitle( el );

		el = document.querySelectorAll( '.tsd-kind-external-module a' );
		cleanLinks( el );

		el = document.querySelectorAll( '.tsd-is-not-exported a' );
		cleanLinks( el );

		el = document.querySelectorAll( '.tsd-breadcrumb a' );
		cleanLinks( el );

		el = document.querySelectorAll( '.tsd-page-title h1' );
		cleanHeadings( el );

		el = document.querySelectorAll( '.tsd-description .tsd-parameters .tsd-comment p' );
		updateDescriptions( el );

		el = document.querySelectorAll( '.tsd-description .tsd-returns-title + p' );
		updateDescriptions( el );
	}
721686
function fileCategoryMap() {

        // Go over every file lookup function we export.
        var exports = module.exports(grunt);
        // This list of categories must contain all non-overlapping file categories.
        var categories = ['extLibFiles', 'extLibMapFiles', 'extCssFiles', 'extFontFiles', 'fontFiles',
            'appIndexFiles', 'testIndexFiles', 'configFiles', 'libFiles', 'modelFiles', 'srcDataFiles',
            'codeFiles', 'otherJsFiles', 'otherNonJsFiles', 'taskFiles', 'cssFiles', 'picFiles', 'soundFiles', 'unitTestFiles',
            'commonJsFiles', 'commonOtherFiles', 'ignoredFiles', 'distUncompressedFiles',
            'distLibFiles', 'distIndexFiles', 'distJsFiles', 'distCssFiles',
            'toolsShellFiles', 'unitTestDataFiles', 'picSrcFiles', 'soundSrcFiles',
            'htmlTemplateFiles', 'generatedJsFiles', 'otherMediaFiles', 'unitTestHelperFiles',
            'pythonFiles', 'compiledPythonFiles', 'localizationDataFiles', 'developmentOtherDataFiles', 'developmentTextDataFiles'];

        // Construct the map by calling each function defined above.
        var map = {};
        for (var i = 0; i < categories.length; i++) {
            var files = flatten(exports[categories[i]]());
            for (var j = 0; j < files.length; j++) {
                if (map[files[j]]) {
                    grunt.fail.warn("A file '" + files[j] + "' maps to category '" + categories[i] + "' in addition to '" + map[files[j]] + "' category.");
                } else {
                    map[files[j]] = categories[i];
                }
            }
        }
        return map;
    }
471324
def make_export(self, exports):
        """"""
        sql = 'drop table if exists export'
        logging.debug(sql)
        self.cursor.execute(sql)
        sql = 'create table if not exists export ' \
              '(func text unique, module text)'
        logging.debug(sql)
        self.cursor.execute(sql)
        for module in exports:
            logging.debug(_('insering exports from %s'), module)
            sql = 'insert into export values (?, ?)'
            for func in exports[module]:
                if func:
                    try:
                        self.cursor.execute(sql, (func, module))
                    except sqlite3.IntegrityError:
                        pass
        self.con.commit()
223995
function makeExtractionCompileOptions(compileOptions, entryFilename, extractions, importer) {
  const extractionCompileOptions = Object.assign({}, compileOptions);
  const extractionFunctions = {};

  // Copy all extraction function for each file into one object for compilation
  Object.keys(extractions).forEach(extractionKey => {
    Object.assign(extractionFunctions, extractions[extractionKey].injectedFunctions);
  });

  extractionCompileOptions.functions = Object.assign(extractionFunctions, compileOptions.functions);
  extractionCompileOptions.data = extractions[entryFilename].injectedData;
  if(!makeExtractionCompileOptions.imported) {
    extractionCompileOptions.importer = importer;
  }

  return extractionCompileOptions;
}