text: "use strict";
  
  // This module should be compatible with PhantomJS v1, just like the other files
  // in reify/lib/runtime. Node 4+ features like const/let and arrow functions are
  // not acceptable here, and importing any npm packages should be contemplated
  // with extreme skepticism.
  
  var useSetPrototypeOf = typeof Object.setPrototypeOf === "function";
  var useSymbol = typeof Symbol === "function";
  
  var esStrKey = "__esModule";
  var esSymKey = useSymbol ? Symbol.for(esStrKey) : null;
  var useToStringTag = useSymbol && typeof Symbol.toStringTag === "symbol";
  var useGetOwnPropDesc =
    typeof Object.getOwnPropertyDescriptor === "function";
  var hasOwn = Object.prototype.hasOwnProperty;
  
  function copyKey(key, target, source) {
    if (useGetOwnPropDesc) {
      var desc = Object.getOwnPropertyDescriptor(source, key);
      desc.configurable = true; // Allow redefinition.
      Object.defineProperty(target, key, desc);
    } else {
      target[key] = source[key];
    }
  }
  
  exports.copyKey = copyKey;
  
  // Returns obj[key] unless that property is defined by a getter function,
  // in which case the getter function is returned.
  exports.valueOrGetter = function (obj, key) {
    if (useGetOwnPropDesc && hasOwn.call(obj, key)) {
      var desc = Object.getOwnPropertyDescriptor(obj, key);
      if (typeof desc.get === "function") {
        return desc.get;
      }
    }
  
    return obj[key];
  };
  
  function getESModule(exported) {
    if (isObjectLike(exported)) {
      if (useSymbol && hasOwn.call(exported, esSymKey)) {
        return !! exported[esSymKey];
      }
  
      if (hasOwn.call(exported, esStrKey)) {
        return !! exported[esStrKey];
      }
    }
  
    return false;
  }
  
  exports.getESModule = getESModule;
  
  function setESModule(exported) {
    if (isObjectLike(exported)) {
      if (useSymbol) {
        exported[esSymKey] = true;
      }
  
      if (! exported[esStrKey]) {
        // Other module runtime systems may set exported.__esModule such
        // that it can't be redefined, so we call Object.defineProperty only
        // when exported.__esModule is not already true.
        Object.defineProperty(exported, esStrKey, {
          configurable: true,
          enumerable: false,
          value: true,
          writable: false
        });
      }
    }
  }
  
  exports.setESModule = setESModule;
  
  function isObject(value) {
    return typeof value === "object" && value !== null;
  }
  
  exports.isObject = isObject;
  
  function isObjectLike(value) {
    var type = typeof value;
    return type === "function" || (type === "object" && value !== null);
  }
  
  exports.isObjectLike = isObjectLike;
  
  function createNamespace() {
    var namespace = Object.create(null);
  
    if (useToStringTag) {
      Object.defineProperty(namespace, Symbol.toStringTag, {
        value: "Module",
        configurable: false,
        enumerable: false,
        writable: false
      });
    }
  
    setESModule(namespace);
  
    return namespace;
  }
  
  exports.createNamespace = createNamespace;
  
  function setPrototypeOf(object, proto) {
    if (useSetPrototypeOf) {
      Object.setPrototypeOf(object, proto);
    } else {
      object.__proto__ = proto;
    }
    return object;
  }
  
  exports.setPrototypeOf = setPrototypeOf;
  