123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.import { validateFunction, validateString } from "./validators.mjs";import { normalizeEncoding, slowCases } from "./normalize_encoding.mjs";export { normalizeEncoding, slowCases };
export const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");export const kEnumerableProperty = Object.create(null);kEnumerableProperty.enumerable = true;
export function once(callback) {  let called = false;  return function (...args) {    if (called) return;    called = true;    Reflect.apply(callback, this, args);  };}
export function createDeferredPromise() {  let resolve;  let reject;  const promise = new Promise((res, rej) => {    resolve = res;    reject = rej;  });
  return { promise, resolve, reject };}
// Keep a list of deprecation codes that have been warned on so we only warn on// each one once.const codesWarned = new Set();
// Mark that a method should not be used.// Returns a modified function which warns once by default.// If --no-deprecation is set, then it is a no-op.export function deprecate(fn, msg, code) {  // TODO(kt3k): Uncomment this  // if (process.noDeprecation === true) {  //  return fn;  // }
  if (code !== undefined) {    validateString(code, "code");  }
  let warned = false;  function deprecated(...args) {    if (!warned) {      warned = true;      if (code !== undefined) {        if (!codesWarned.has(code)) {          process.emitWarning(msg, "DeprecationWarning", code, deprecated);          codesWarned.add(code);        }      } else {        process.emitWarning(msg, "DeprecationWarning", deprecated);      }    }    if (new.target) {      return Reflect.construct(fn, args, new.target);    }    return Reflect.apply(fn, this, args);  }
  // The wrapper will keep the same prototype as fn to maintain prototype chain  Object.setPrototypeOf(deprecated, fn);  if (fn.prototype) {    // Setting this (rather than using Object.setPrototype, as above) ensures    // that calling the unwrapped constructor gives an instanceof the wrapped    // constructor.    deprecated.prototype = fn.prototype;  }
  return deprecated;}
// In addition to being accessible through util.promisify.custom,// this symbol is registered globally and can be accessed in any environment as// Symbol.for('nodejs.util.promisify.custom').const kCustomPromisifiedSymbol = Symbol.for("nodejs.util.promisify.custom");// This is an internal Node symbol used by functions returning multiple// arguments, e.g. ['bytesRead', 'buffer'] for fs.read().const kCustomPromisifyArgsSymbol = Symbol.for(  "nodejs.util.promisify.customArgs",);
export const customPromisifyArgs = kCustomPromisifyArgsSymbol;
export function promisify(  original,) {  validateFunction(original, "original");  if (original[kCustomPromisifiedSymbol]) {    const fn = original[kCustomPromisifiedSymbol];
    validateFunction(fn, "util.promisify.custom");
    return Object.defineProperty(fn, kCustomPromisifiedSymbol, {      value: fn,      enumerable: false,      writable: false,      configurable: true,    });  }
  // Names to create an object from in case the callback receives multiple  // arguments, e.g. ['bytesRead', 'buffer'] for fs.read.  const argumentNames = original[kCustomPromisifyArgsSymbol];  function fn(...args) {    return new Promise((resolve, reject) => {      args.push((err, ...values) => {        if (err) {          return reject(err);        }        if (argumentNames !== undefined && values.length > 1) {          const obj = {};          for (let i = 0; i < argumentNames.length; i++) {            obj[argumentNames[i]] = values[i];          }          resolve(obj);        } else {          resolve(values[0]);        }      });      Reflect.apply(original, this, args);    });  }
  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
  Object.defineProperty(fn, kCustomPromisifiedSymbol, {    value: fn,    enumerable: false,    writable: false,    configurable: true,  });  return Object.defineProperties(    fn,    Object.getOwnPropertyDescriptors(original),  );}
promisify.custom = kCustomPromisifiedSymbol;
export default {  createDeferredPromise,  customInspectSymbol,  kEnumerableProperty,  normalizeEncoding,  once,  deprecate,  promisify,};