text: /**
   * @license
   * Copyright 2013 The Emscripten Authors
   * SPDX-License-Identifier: MIT
   */
  
  // Implementation of libuuid creating RFC4122 version 4 random UUIDs.
  
  mergeInto(LibraryManager.library, {
    // Clear a 'compact' UUID.
    uuid_clear__deps: ['$zeroMemory'],
    uuid_clear: function(uu) {
      // void uuid_clear(uuid_t uu);
      zeroMemory(uu, 16);
    },
  
    // Compare whether or not two 'compact' UUIDs are the same.
    // Returns an integer less than, equal to, or greater than zero if uu1  is found, respectively, to be
    // lexigraphically  less  than,  equal, or greater than uu2.
    uuid_compare__deps: ['memcmp'],
    uuid_compare: function(uu1, uu2) {
      // int uuid_compare(const uuid_t uu1, const uuid_t uu2);
      return _memcmp(uu1, uu2, 16);
    },
  
    // Copies the 'compact' UUID variable from src to dst.
    uuid_copy: function(dst, src) {
      // void uuid_copy(uuid_t dst, const uuid_t src);
      _memcpy(dst, src, 16);
    },
  
    // Write a RFC4122 version 4 compliant UUID largely based on the method found in
    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
    // tweaked slightly in order to use the 'compact' UUID form used by libuuid.
    uuid_generate: function(out) {
      // void uuid_generate(uuid_t out);
      var uuid = null;
  
      if (ENVIRONMENT_IS_NODE) {
  #if ENVIRONMENT_MAY_BE_NODE
        // If Node.js try to use crypto.randomBytes
        try {
          var rb = require('crypto')['randomBytes'];
          uuid = rb(16);
        } catch(e) {}
  #endif // ENVIRONMENT_MAY_BE_NODE
      } else if (ENVIRONMENT_IS_WEB &&
                 typeof(window.crypto) !== 'undefined' &&
                 typeof(window.crypto.getRandomValues) !== 'undefined') {
        // If crypto.getRandomValues is available try to use it.
        uuid = new Uint8Array(16);
        window.crypto.getRandomValues(uuid);
      }
  
      // Fall back to Math.random if a higher quality random number generator is not available.
      if (!uuid) {
        uuid = new Array(16);
        var d = new Date().getTime();
        for (var i = 0; i < 16; i++) {
          var r = ((d + Math.random() * 256) % 256)|0;
          d = (d / 256)|0;
          uuid[i] = r;
        }
      }
  
      // Makes uuid compliant to RFC-4122
      uuid[6] = (uuid[6] & 0x0F) | 0x40; // uuid version
      uuid[8] = (uuid[8] & 0x3F) | 0x80; // uuid variant
      writeArrayToMemory(uuid, out);
    },
  
    // Compares the value of the supplied 'compact' UUID variable uu to the NULL value.
    // If the value is equal to the NULL UUID, 1 is returned, otherwise 0 is returned.
    uuid_is_null: function(uu) {
      // int uuid_is_null(const uuid_t uu);
      for (var i = 0; i < 4; i++, uu = (uu+4)|0) {
        var val = {{{ makeGetValue('uu', 0, 'i32') }}};
        if (val) {
          return 0;
        }
      }
      return 1;
    },
  
    // converts the UUID string given by inp into the binary representation. The input UUID is a string of
    // the form "%08x-%04x-%04x-%04x-%012x" 36 bytes plus the trailing '\0'.
    // Upon successfully parsing the input string, 0 is returned, and the UUID is stored in the location
    // pointed to by uu, otherwise -1 is returned.
    uuid_parse: function(inp, uu) {
      // int uuid_parse(const char *in, uuid_t uu);
      inp = UTF8ToString(inp);
      if (inp.length === 36) {
        var i = 0;
        var uuid = new Array(16);
        inp.toLowerCase().replace(/[0-9a-f]{2}/g, function(byte) {
          if (i < 16) {
            uuid[i++] = parseInt(byte, 16);
          }
        });
  
        if (i < 16) {
          return -1;
        } else {
          writeArrayToMemory(uuid, uu);
          return 0;
        }
      } else {
        return -1;
      }
    },
  
    // Convert a 'compact' form UUID to a string, if the upper parameter is supplied make the string upper case.
    uuid_unparse__docs: '/** @param {number|boolean=} upper */',
    uuid_unparse: function(uu, out, upper) {
      // void uuid_unparse(const uuid_t uu, char *out);
      var i = 0;
      var uuid = 'xxxx-xx-xx-xx-xxxxxx'.replace(/[x]/g, function(c) {
        var r = upper ? ({{{ makeGetValue('uu', 'i', 'i8', 0, 1) }}}).toString(16).toUpperCase() :
                        ({{{ makeGetValue('uu', 'i', 'i8', 0, 1) }}}).toString(16);
        r = (r.length === 1) ? '0' + r : r; // Zero pad single digit hex values
        i++;
        return r;
      });
      stringToUTF8(uuid, out, 37); // Always fixed 36 bytes of ASCII characters and a trailing \0.
    },
  
    // Convert a 'compact' form UUID to a lower case string.
    uuid_unparse_lower__deps: ['uuid_unparse'],
    uuid_unparse_lower: function(uu, out) {
      // void uuid_unparse_lower(const uuid_t uu, char *out);
      _uuid_unparse(uu, out);
    },
  
    // Convert a 'compact' form UUID to an upper case string.
    uuid_unparse_upper__deps: ['uuid_unparse'],
    uuid_unparse_upper: function(uu, out) {
      // void uuid_unparse_upper(const uuid_t uu, char *out);
      _uuid_unparse(uu, out, true);
    },
  
    uuid_type: function(uu) {
      // int uuid_type(const uuid_t uu);
      return {{{ cDefine('UUID_TYPE_DCE_RANDOM') }}};
    },
  
    uuid_variant: function(uu) {
      // int uuid_variant(const uuid_t uu);
      return {{{ cDefine('UUID_VARIANT_DCE') }}};
    }
  });
  
  