How to use builtins

get options() {
  return {
   ...(this.defaultOptions || {}),
   ...((this.polly.config.adapterOptions || {})[this.constructor.id] || {})
  };
 }

async record(pollyRequest) {
  pollyRequest.action = ACTIONS.RECORD;

  if ('navigator' in global && !navigator.onLine) {
   console.warn(
    '[Polly] Recording may fail because the browser is offline.\n' +
     `${stringifyRequest(pollyRequest)}`
   );
  }

  return this.onRecord(pollyRequest);
 }

export default function isExpired(recordedOn, expiresIn) {
 if (recordedOn && expiresIn) {
  return (
   new Date() >
   new Date(new Date(recordedOn).getTime() + dehumanizeTime(expiresIn))
  );
 }

 return false;
}

export default function normalizeRecordedResponse(response) {
 const { status, statusText, headers, content } = response;

 return {
  statusText,
  statusCode: status,
  headers: normalizeHeaders(headers),
  body: content && content.text,
  isBinary: Boolean(content && content._isBinary)
 };
}

async findRecording(recordingId) {
  const response = await this.ajax(`/${encodeURIComponent(recordingId)}`, {
   Accept: 'application/json; charset=utf-8'
  });

  return this._normalize(response);
 }

export default function buildUrl(...paths) {
 const url = new URL(
  paths
   .map(p => p && (p + '').trim()) // Trim each string
   .filter(Boolean) // Remove empty strings or other falsy paths
   .join('/')
 );

 // Replace 2+ consecutive slashes with 1. (e.g. `///` --> `/`)
 url.set('pathname', url.pathname.replace(/\/{2,}/g, '/'));

 return url.href;
}

/**
 * Determine if the given buffer is utf8.
 * @param {Buffer} buffer
 */
export default function isBufferUtf8Representable(buffer) {
 const utfEncodedBuffer = buffer.toString('utf8');
 const reconstructedBuffer = Buffer.from(utfEncodedBuffer, 'utf8');

 return reconstructedBuffer.equals(buffer);
}

saveRecording(recordingId, data) {
  /*
   Pass the data through the base persister's stringify method so
   the output will be consistent with the rest of the persisters.
  */
  this.api.saveRecording(recordingId, parse(this.stringify(data)));
 }

export default function getBufferFromStream(stream) {
 return new Promise(resolve => {
  const chunks = [];

  stream.on('data', chunk => {
   chunks.push(chunk);
  });

  stream.on('end', () => {
   resolve(Buffer.concat(chunks));
  });
 });
}

logError(request, error) {
  this.groupStart(request.recordingName);

  console.group(`Errored ➞ ${request.method} ${request.url}`);
  console.error(error);
  console.log('Request:', request);

  if (request.didRespond) {
   console.log('Response:', request.response);
  }

  console.log('Identifiers:', request.identifiers);
  console.groupEnd();
 }

function customizer(objValue, srcValue, key) {
 // Arrays and `context` options should just replace the existing value
 // and not be deep merged.
 if (Array.isArray(objValue) || ['context'].includes(key)) {
  return srcValue;
 }
}

it('.emitSync() - stopPropagation', async function() {
   const array = [];

   emitter.on('a', e => {
    e.stopPropagation();
    array.push(1);
   });
   emitter.on('a', () => array.push(2));

   expect(emitter.emitSync('a')).to.be.false;
   expect(array).to.have.ordered.members([1]);
  });

export function headers(headers, config, req) {
 const normalizedHeaders = new HTTPHeaders(headers);

 if (isFunction(config)) {
  return config(normalizedHeaders, req);
 }

 if (isObjectLike(config) && isArray(config.exclude)) {
  config.exclude.forEach(header => delete normalizedHeaders[header]);
 }

 return normalizedHeaders;
}

static register(Factory) {
  if (!FACTORY_REGISTRATION.has(Factory)) {
   FACTORY_REGISTRATION.set(Factory, container =>
    container.register(Factory)
   );
  }

  this.on('register', FACTORY_REGISTRATION.get(Factory));

  return this;
 }

function guidFor(str) {
 const hash = fnv1a(str).toString();
 let slug = slugify(sanitize(str));

 // Max the slug at 100 char
 slug = slug.substring(0, 100 - hash.length - 1);

 return `${slug}_${hash}`;
}