How to use strip-bom - 10 common examples

import stripBom from 'strip-bom';

const result: string = stripBom('\uFEFFunicorn');
//=> 'unicorn'

// $ExpectError
stripBom(42);

// $ExpectError
(stripBom('asdf'): number);

require.extensions[ext] = (mod, filename) => {
                // NOTE: remove global API so that it will be unavailable for the dependencies
                this._removeGlobalAPI();

                if (APIBasedTestFileCompilerBase._isNodeModulesDep(filename) && origExt)
                    origExt(mod, filename);

                else {
                    const code         = readFileSync(filename).toString();
                    const compiledCode = requireCompilers[ext](stripBom(code), filename);

                    mod.paths = APIBasedTestFileCompilerBase._getNodeModulesLookupPath(filename);

                    mod._compile(compiledCode, filename);
                }

                this._addGlobalAPI(testFile);
            };
        });

function getVersion() {
    const packageJsonContent = fs.readFileSync(path.resolve(currentFilename, '../../package.json'), { encoding: 'utf-8' });
    const { version } = map(JSON.parse(stripBOM(packageJsonContent)));
    return version;
}
function findProjectRoot(base) {

return new Promise((resolve, reject) => {
      if (
        fs.existsSync(ignoreDirectory)
        && fs.existsSync(DOT.IGNORE.PATH)
      ) {
        const buffer = stripBom(fs.readFileSync(DOT.IGNORE.PATH, FS_OPTIONS));
        resolve(splitLines(buffer).filter((name: string) => name));
      } else {
        const defaultClaspignore = [
          '# ignore all files...',
          '**/**',
          '',
          '# except the extensions...',
          '!appsscript.json',
          '!**/*.gs',
          '!**/*.js',
          '!**/*.ts',
          '!**/*.html',
          '',
          '# ignore even valid files if in...',
          '.git/**',
          'node_modules/**',

fs.readFile(file, { encoding: "utf-8" }, (readError, data) => {
    if (readError) {
      return callback(readError)
    }

    const json = stripComments(stripBom(data))

    let obj
    try {
      obj = JSON.parse(json)
    } catch (decodeError) {
      decodeError.message = `${file}: ${decodeError.message}`
      return callback(decodeError)
    }

    return callback(null, obj)
  })
}

function getVersion() {
  const packageJsonContent = fs.readFileSync(path.resolve(currentFilename, '../../package.json'), {encoding: 'utf-8'});
  const {version} = map(JSON.parse(stripBOM(packageJsonContent)));
  return version;
}

export default function(str: string, fileLoc: string = 'lockfile'): ParseResult {
  str = stripBOM(str);
  return hasMergeConflicts(str) ? parseWithConflict(str, fileLoc) : {type: 'success', object: parse(str, fileLoc)};
}

if (this.params.resolver) {
      runtimeName = this.params.resolver.absPathToRuntimeName(moduleName) || moduleName;
    } else {
      runtimeName = moduleName;
    }

    let opts = this.syntax.defaultOptions({ contents, moduleName });
    if (this.params.resolver) {
      let transform = this.params.resolver.astTransformer(this);
      if (transform) {
        this.params.plugins.ast!.push(transform);
      }
    }
    opts.plugins!.ast = [...this.getReversedASTPlugins(this.params.plugins.ast!), ...opts.plugins!.ast!];

    let compiled = this.syntax.precompile(stripBom(contents), {
      contents,
      moduleName: runtimeName,
      filename: moduleName,
      plugins: opts.plugins,
    });

    if (this.params.resolver) {
      dependencies = this.params.resolver.dependenciesOf(moduleName);
    } else {
      dependencies = [];
    }

    return { compiled, dependencies };
  }

export async function readJsonAndFile(
  loc: string,
): Promise<{
  object: Object;
  content: string;
}> {
  const file = await readFile(loc);
  try {
    return {
      object: map(JSON.parse(stripBOM(file))),
      content: file,
    };
  } catch (err) {
    err.message = `${loc}: ${err.message}`;
    throw err;
  }
}

function streamFile(file, cb) {
  file.contents = fs.createReadStream(file.path)
    .pipe(stripBom.stream());

  cb(null, file);
}