API tools faq
paste
ff19

benchlab-kepleruuid

ff19
Jul 7th, 2018
341
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 35.06 KB | None | 0 0
raw download clone embed print report
  1. diff --git b/bower.json a/bower.json
  2. old mode 100755
  3. new mode 100644
  4. index 57edd21..b5f1421
  5. --- b/bower.json
  6. +++ a/bower.json
  7. @@ -1,29 +1,29 @@
  8.  {
  9. -  "name": "uuid.js",
  10. -  "homepage": "https://github.com/LiosK/UUID.js",
  11. -  "description": "UUID.js - RFC-compliant UUID Generator for JavaScript",
  12. -  "main": "src/uuid.js",
  13. -  "moduleType": [
  14. -    "globals"
  15. -  ],
  16. -  "keywords": [
  17. -    "library",
  18. -    "uuid",
  19. -    "guid",
  20. -    "rfc",
  21. -    "4122",
  22. -    "universally",
  23. -    "globally",
  24. -    "unique",
  25. -    "identifier"
  26. -  ],
  27. -  "authors": [
  28. -    "LiosK <[email protected]>"
  29. -  ],
  30. -  "license": "Apache-2.0",
  31. -  "ignore": [
  32. -    "**/.*",
  33. -    "docs",
  34. -    "test"
  35. -  ]
  36. +    "name": "kepleruuid",
  37. +    "homepage": "https://github.com/benchlab/kepleruuid",
  38. +    "description": "Kepler's RFC-compliant UUID Javascript Librarty for Bench Network's Kepler ID Sets and Network Objects. Design For Use With KeplerJS.",
  39. +    "main": "src/kepler_uuid.js",
  40. +    "moduleType": [
  41. +        "globals"
  42. +    ],
  43. +    "keywords": [
  44. +        "bench-network",
  45. +        "kepler",
  46. +        "keplerjs",
  47. +        "keplerbase",
  48. +        "kepler-uuid",
  49. +        "uuid-generator",
  50. +        "uuid-javascript",
  51. +        "blockchain-id",
  52. +        "decentralized"
  53. +    ],
  54. +    "authors": [
  55. +        "Jared Rice Sr. <[email protected]>"
  56. +    ],
  57. +    "license": "Apache-2.0",
  58. +    "ignore": [
  59. +        "**/.*",
  60. +        "docs",
  61. +        "test"
  62. +    ]
  63.  }
  64. diff --git b/dist/kepleruuid.core.js a/dist/kepleruuid.core.js
  65. old mode 100755
  66. new mode 100644
  67. index 454cc4a..2f43f7c
  68. --- b/dist/kepleruuid.core.js
  69. +++ a/dist/kepleruuid.core.js
  70. @@ -1,7 +1,22 @@
  71. -/*
  72. - Version: v4.0.3
  73. - Apache License 2.0: Copyright (c) 2010-2017 LiosK
  74. -*/
  75. -var UUID;
  76. -UUID=function(f){function a(){}a.generate=function(){var b=a._getRandomInt,c=a._hexAligner;return c(b(32),8)+"-"+c(b(16),4)+"-"+c(16384|b(12),4)+"-"+c(32768|b(14),4)+"-"+c(b(48),12)};a._getRandomInt=function(b){if(0>b||53<b)return NaN;var c=0|1073741824*Math.random();return 30<b?c+1073741824*(0|Math.random()*(1<<b-30)):c>>>30-b};a._hexAligner=function(b,c){for(var a=b.toString(16),d=c-a.length,e="0";0<d;d>>>=1,e+=e)d&1&&(a=e+a);return a};a.overwrittenUUID=f;"object"===typeof module&&"object"===typeof module.exports&&
  77. -(module.exports=a);return a}(UUID);
  78. +var KeplerUUID;
  79. +KeplerUUID = function (f) {
  80. +    function a() {}
  81. +    a.build = function () {
  82. +        var b = a._getRandomInt,
  83. +            c = a._hexAligner;
  84. +        return c(b(32), 8) + "-" + c(b(16), 4) + "-" + c(16384 | b(12), 4) + "-" + c(32768 | b(14), 4) + "-" + c(b(48), 12)
  85. +    };
  86. +    a._getRandomInt = function (b) {
  87. +        if (0 > b || 53 < b) return NaN;
  88. +        var c = 0 | 1073741824 * Math.random();
  89. +        return 30 < b ? c + 1073741824 * (0 | Math.random() * (1 << b - 30)) : c >>> 30 - b
  90. +    };
  91. +    a._hexAligner = function (b, c) {
  92. +        for (var a = b.toString(16), d = c - a.length, e = "0"; 0 < d; d >>>= 1, e += e) d & 1 && (a = e + a);
  93. +        return a
  94. +    };
  95. +    a.overwrittenUUID = f;
  96. +    "object" === typeof module && "object" === typeof module.exports &&
  97. +        (module.exports = a);
  98. +    return a
  99. +}(KeplerUUID);
  100. \ No newline at end of file
  101. diff --git b/package.json a/package.json
  102. old mode 100755
  103. new mode 100644
  104. index 5e0d3ec..9ae33ea
  105. --- b/package.json
  106. +++ a/package.json
  107. @@ -1,44 +1,58 @@
  108.  {
  109. -  "name": "uuidjs",
  110. -  "version": "4.0.3",
  111. -  "title": "UUID.js",
  112. -  "description": "RFC-compliant UUID Generator for JavaScript",
  113. -  "main": "src/uuid.js",
  114. -  "types": "types/uuidjs/index.d.ts",
  115. +  "name": "kepleruuid",
  116. +<<<<<<< HEAD
  117. +  "version": "1.0.8",
  118. +=======
  119. +  "version": "1.0.7",
  120. +>>>>>>> development/production
  121. +  "title": "KeplerUUID",
  122. +  "description": "Kepler's RFC-compliant UUID Javascript Librarty for Bench Network's Kepler ID Sets and Network Objects. Design For Use With KeplerJS.",
  123. +  "main": "src/kepleruuidjs.js",
  124. +  "types": "types/kepleruuidjs/index.d.ts",
  125.    "directories": {
  126.      "doc": "docs",
  127.      "test": "test"
  128.    },
  129. -  "tonicExampleFilename": "example.js",
  130. +  "tonicExampleFilename": "kepler_test.js",
  131.    "scripts": {
  132.      "test": "qunit test/nodejs.js",
  133. -    "test-ts": "tsc --strict --noEmit types/uuidjs/uuidjs-tests.ts",
  134. -    "jsdoc": "jsdoc -R README.md -d docs src/uuid.js"
  135. +    "test-ts": "tsc --strict --noEmit types/kepleruuid/kepleruuid-tests.ts",
  136. +    "jsdoc": "jsdoc -R README.md -d docs src/kepleruuid.js"
  137.    },
  138.    "repository": {
  139.      "type": "git",
  140. -    "url": "https://github.com/LiosK/UUID.js.git"
  141. +    "url": "https://github.com/benchlab/KeplerUUID.git"
  142.    },
  143.    "keywords": [
  144. -    "library",
  145. -    "uuid",
  146. -    "guid",
  147. -    "rfc",
  148. -    "4122",
  149. -    "universally",
  150. -    "globally",
  151. -    "unique",
  152. -    "identifier"
  153. +    "bench-network",
  154. +    "kepler",
  155. +    "keplerjs",
  156. +    "keplerbase",
  157. +    "kepler-uuid",
  158. +    "uuid-generator",
  159. +    "uuid-javascript",
  160. +    "blockchain-id",
  161. +    "decentralized"
  162.    ],
  163. -  "author": "LiosK <[email protected]>",
  164. -  "license": "Apache-2.0",
  165. +  "author": "Jared Rice Sr. <[email protected]>",
  166. +  "license": "BENCH",
  167.    "bugs": {
  168. -    "url": "https://github.com/LiosK/UUID.js/issues"
  169. +    "url": "https://github.com/benchlab/KeplerUUID/issues"
  170.    },
  171. -  "homepage": "https://github.com/LiosK/UUID.js",
  172. +  "homepage": "https://github.com/benchlab/KeplerUUID",
  173.    "devDependencies": {
  174.      "jsdoc": "^3.5.5",
  175. +    "kepleruuidtest": "latest",
  176.      "qunit": "^2.4.1",
  177.      "typescript": "^2.6.2"
  178. +  },
  179. +  "dependencies": {
  180. +    "bower": "^1.8.4",
  181. +    "global": "^4.3.2",
  182. +<<<<<<< HEAD
  183. +    "kepleruuidtest": "latest"
  184. +=======
  185. +    "kepleruuid.js": "latest"
  186. +>>>>>>> development/production
  187.    }
  188.  }
  189. diff --git b/src/kepleruuid.core.js a/src/kepleruuid.core.js
  190. old mode 100755
  191. new mode 100644
  192. index a880e90..7a1db47
  193. --- b/src/kepleruuid.core.js
  194. +++ a/src/kepleruuid.core.js
  195. @@ -1,39 +1,39 @@
  196.  /**
  197. - * UUID.core.js - UUID.js for Minimalists
  198. + * keplerUUID - Kepler 's RFC-compliant UUID Javascript Library for Bench Network's Kepler ID Sets and Network Objects.
  199.   *
  200.   * @file
  201. - * @author  LiosK
  202. - * @version v4.0.3
  203. - * @license Apache License 2.0: Copyright (c) 2010-2017 LiosK
  204. + * @author  BenchX
  205. + * @version v1.0.0
  206. + * @license BENCH License 1.0: Copyright (c) 2018 Bench Computer, Inc.
  207.   */
  208.  
  209.  /**
  210.   * @class
  211. - * @classdesc {@link UUID} object.
  212. + * @classdesc {@link keplerUUID} object.
  213.   * @hideconstructor
  214.   */
  215. -var UUID;
  216. +var keplerUUID;
  217.  
  218. -UUID = (function(overwrittenUUID) {
  219. +keplerUUID = (function(overwrittenKeplerUUID) {
  220.  "use strict";
  221.  
  222. -// Core Component {{{
  223. +// Kepler Core UUID Builder Component {{{
  224.  
  225.  /**
  226. - * Generates a version 4 UUID as a hexadecimal string.
  227. - * @returns {string} Hexadecimal UUID string.
  228. + * Creates hexidecimal version of a v4 Kepler UUID and returns as a string.
  229. + * @returns {string} Hexadecimal Kepler v4 UUID string.
  230.   */
  231. -UUID.generate = function() {
  232. -  var rand = UUID._getRandomInt, hex = UUID._hexAligner;
  233. -  return  hex(rand(32), 8)          // time_low
  234. +keplerUUID.builder = function() {
  235. +  var rand = keplerUUID._getRandomInt, hex = keplerUUID._hexAligner;
  236. +  return  hex(rand(32), 8)          // Kepler UUID `time_low`
  237.          + "-"
  238. -        + hex(rand(16), 4)          // time_mid
  239. +        + hex(rand(16), 4)          // Kepler UUID `time_mid`
  240.          + "-"
  241. -        + hex(0x4000 | rand(12), 4) // time_hi_and_version
  242. +        +hex(0x4000 | rand(12), 4) // Kepler UUID `time_hi_and_version`
  243.          + "-"
  244. -        + hex(0x8000 | rand(14), 4) // clock_seq_hi_and_reserved clock_seq_low
  245. +        +hex(0x8000 | rand(14), 4) // Kepler UUID `clock_seq_hi_and_reserved` `clock_seq_low`
  246.          + "-"
  247. -        + hex(rand(48), 12);        // node
  248. +        +hex(rand(48), 12); // Kepler UUID `node`
  249.  };
  250.  
  251.  /**
  252. @@ -42,7 +42,7 @@ UUID.generate = function() {
  253.   * @param {number} x Unsigned integer ranging from 0 to 53, inclusive.
  254.   * @returns {number} Unsigned x-bit random integer (0 <= f(x) < 2^x).
  255.   */
  256. -UUID._getRandomInt = function(x) {
  257. +keplerUUID._getRandomInt = function(x) {
  258.    if (x < 0 || x > 53) { return NaN; }
  259.    var n = 0 | Math.random() * 0x40000000; // 1 << 30
  260.    return x > 30 ? n + (0 | Math.random() * (1 << x - 30)) * 0x40000000 : n >>> 30 - x;
  261. @@ -55,31 +55,31 @@ UUID._getRandomInt = function(x) {
  262.   * @param {number} length
  263.   * @returns {string}
  264.   */
  265. -UUID._hexAligner = function(num, length) {
  266. +keplerUUID._hexAligner = function(num, length) {
  267.    var str = num.toString(16), i = length - str.length, z = "0";
  268.    for (; i > 0; i >>>= 1, z += z) { if (i & 1) { str = z + str; } }
  269.    return str;
  270.  };
  271.  
  272.  /**
  273. - * Retains the value of 'UUID' global variable assigned before loading UUID.js.
  274. + * Retains the value of 'keplerUUID' global variable assigned before loading keplerUUID.js.
  275.   * @since 3.2
  276.   * @type {any}
  277.   */
  278. -UUID.overwrittenUUID = overwrittenUUID;
  279. +keplerUUID.overwrittenKeplerUUID = overwrittenKeplerUUID;
  280.  
  281.  // }}}
  282.  
  283.  // create local namespace
  284. -function UUID() {}
  285. +function keplerUUID() {}
  286.  
  287.  // for nodejs
  288.  if (typeof module === "object" && typeof module.exports === "object") {
  289. -  module.exports = UUID;
  290. +  module.exports = keplerUUID;
  291.  }
  292.  
  293. -return UUID;
  294. +return keplerUUID;
  295.  
  296. -})(UUID);
  297. +})(keplerUUID);
  298.  
  299.  // vim: fdm=marker fmr&
  300. diff --git b/src/kepleruuid.js a/src/kepleruuid.js
  301. old mode 100755
  302. new mode 100644
  303. index 3ba9243..f9dbac3
  304. --- b/src/kepleruuid.js
  305. +++ a/src/kepleruuid.js
  306. @@ -1,30 +1,30 @@
  307.  /**
  308. - * UUID.js - RFC-compliant UUID Generator for JavaScript
  309. + * keplerUUID - Kepler 's RFC-compliant UUID Javascript Library for Bench Network's Kepler ID Sets and Network Objects.
  310.   *
  311.   * @file
  312. - * @author  LiosK
  313. - * @version v4.0.3
  314. - * @license Apache License 2.0: Copyright (c) 2010-2017 LiosK
  315. + * @author  BenchX
  316. + * @version v1.0.0
  317. + * @license BENCH License 1.0: Copyright (c) 2018 Bench Computer, Inc.
  318.   */
  319.  
  320.  /**
  321.   * @class
  322. - * @classdesc {@link UUID} object.
  323. + * @classdesc {@link keplerUUID} object.
  324.   * @hideconstructor
  325.   */
  326. -var UUID;
  327. +var keplerUUID;
  328.  
  329. -UUID = (function(overwrittenUUID) {
  330. +keplerUUID = (function(overwrittenKeplerUUID) {
  331.  "use strict";
  332.  
  333. -// Core Component {{{
  334. +// Core Kepler UUID Generator Component {{{
  335.  
  336.  /**
  337. - * Generates a version 4 UUID as a hexadecimal string.
  338. - * @returns {string} Hexadecimal UUID string.
  339. + * Generates a v4 Kepler UUID as a hexadecimal string.
  340. + * @returns {string} Hexadecimal keplerUUID string.
  341.   */
  342. -UUID.generate = function() {
  343. -  var rand = UUID._getRandomInt, hex = UUID._hexAligner;
  344. +keplerUUID.builder = function() {
  345. +  var rand = keplerUUID._getRandomInt, hex = keplerUUID._hexAligner;
  346.    return  hex(rand(32), 8)          // time_low
  347.          + "-"
  348.          + hex(rand(16), 4)          // time_mid
  349. @@ -42,7 +42,7 @@ UUID.generate = function() {
  350.   * @param {number} x Unsigned integer ranging from 0 to 53, inclusive.
  351.   * @returns {number} Unsigned x-bit random integer (0 <= f(x) < 2^x).
  352.   */
  353. -UUID._getRandomInt = function(x) {
  354. +keplerUUID._getRandomInt = function(x) {
  355.    if (x < 0 || x > 53) { return NaN; }
  356.    var n = 0 | Math.random() * 0x40000000; // 1 << 30
  357.    return x > 30 ? n + (0 | Math.random() * (1 << x - 30)) * 0x40000000 : n >>> 30 - x;
  358. @@ -55,18 +55,18 @@ UUID._getRandomInt = function(x) {
  359.   * @param {number} length
  360.   * @returns {string}
  361.   */
  362. -UUID._hexAligner = function(num, length) {
  363. +keplerUUID._hexAligner = function(num, length) {
  364.    var str = num.toString(16), i = length - str.length, z = "0";
  365.    for (; i > 0; i >>>= 1, z += z) { if (i & 1) { str = z + str; } }
  366.    return str;
  367.  };
  368.  
  369.  /**
  370. - * Retains the value of 'UUID' global variable assigned before loading UUID.js.
  371. + * Retains the value of 'keplerUUID' global variable assigned before loading keplerUUID.js.
  372.   * @since 3.2
  373.   * @type {any}
  374.   */
  375. -UUID.overwrittenUUID = overwrittenUUID;
  376. +keplerUUID.overwrittenKeplerUUID = overwrittenKeplerUUID;
  377.  
  378.  // }}}
  379.  
  380. @@ -74,15 +74,15 @@ UUID.overwrittenUUID = overwrittenUUID;
  381.  
  382.  (function() {
  383.  
  384. -  var mathPRNG = UUID._getRandomInt;
  385. +  var mathPRNG = keplerUUID._getRandomInt;
  386.  
  387.    /**
  388.     * Enables Math.random()-based pseudorandom number generator instead of cryptographically safer options.
  389.     * @since v3.5.0
  390.     * @deprecated This method is provided only to work around performance drawbacks of the safer algorithms.
  391.     */
  392. -  UUID.useMathRandom = function() {
  393. -    UUID._getRandomInt = mathPRNG;
  394. +  keplerUUID.useMathRandom = function() {
  395. +    keplerUUID._getRandomInt = mathPRNG;
  396.    };
  397.  
  398.    var crypto = null, cryptoPRNG = mathPRNG;
  399. @@ -106,58 +106,58 @@ UUID.overwrittenUUID = overwrittenUUID;
  400.        };
  401.      }
  402.    }
  403. -  UUID._getRandomInt = cryptoPRNG;
  404. +  keplerUUID._getRandomInt = cryptoPRNG;
  405.  
  406.  })();
  407.  
  408.  // }}}
  409.  
  410. -// UUID Object Component {{{
  411. +// keplerUUID Object Component {{{
  412.  
  413.  /**
  414. - * Names of UUID internal fields.
  415. + * Names of keplerUUID internal fields.
  416.   * @type {string[]}
  417.   * @constant
  418.   * @since 3.0
  419.   */
  420. -UUID.FIELD_NAMES = ["timeLow", "timeMid", "timeHiAndVersion",
  421. +keplerUUID.FIELD_NAMES = ["timeLow", "timeMid", "timeHiAndVersion",
  422.                      "clockSeqHiAndReserved", "clockSeqLow", "node"];
  423.  
  424.  /**
  425. - * Sizes of UUID internal fields.
  426. + * Sizes of keplerUUID internal fields.
  427.   * @type {number[]}
  428.   * @constant
  429.   * @since 3.0
  430.   */
  431. -UUID.FIELD_SIZES = [32, 16, 16, 8, 8, 48];
  432. +keplerUUID.FIELD_SIZES = [32, 16, 16, 8, 8, 48];
  433.  
  434.  /**
  435. - * Creates a version 4 {@link UUID} object.
  436. - * @returns {UUID} Version 4 {@link UUID} object.
  437. + * Creates a version 4 {@link keplerUUID} object.
  438. + * @returns {keplerUUID} Version 4 {@link keplerUUID} object.
  439.   * @since 3.0
  440.   */
  441. -UUID.genV4 = function() {
  442. -  var rand = UUID._getRandomInt;
  443. -  return new UUID()._init(rand(32), rand(16), // time_low time_mid
  444. +keplerUUID.genV4 = function() {
  445. +  var rand = keplerUUID._getRandomInt;
  446. +  return new keplerUUID()._init(rand(32), rand(16), // time_low time_mid
  447.                            0x4000 | rand(12),  // time_hi_and_version
  448.                            0x80   | rand(6),   // clock_seq_hi_and_reserved
  449.                            rand(8), rand(48)); // clock_seq_low node
  450.  };
  451.  
  452.  /**
  453. - * Converts a hexadecimal UUID string to a {@link UUID} object.
  454. - * @param {string} strId Hexadecimal UUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
  455. - * @returns {UUID} {@link UUID} object or null.
  456. + * Converts a hexadecimal keplerUUID string to a {@link keplerUUID} object.
  457. + * @param {string} strId Hexadecimal keplerUUID string ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
  458. + * @returns {keplerUUID} {@link keplerUUID} object or null.
  459.   * @since 3.0
  460.   */
  461. -UUID.parse = function(strId) {
  462. -  var r, p = /^\s*(urn:uuid:|\{)?([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})(\})?\s*$/i;
  463. +keplerUUID.parse = function(strId) {
  464. +  var r, p = /^\s*(urn:keplerUUID:|\{)?([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{12})(\})?\s*$/i;
  465.    if (r = p.exec(strId)) {
  466.      var l = r[1] || "", t = r[8] || "";
  467.      if (((l + t) === "") ||
  468.          (l === "{" && t === "}") ||
  469. -        (l.toLowerCase() === "urn:uuid:" && t === "")) {
  470. -      return new UUID()._init(parseInt(r[2], 16), parseInt(r[3], 16),
  471. +        (l.toLowerCase() === "urn:keplerUUID:" && t === "")) {
  472. +      return new keplerUUID()._init(parseInt(r[2], 16), parseInt(r[3], 16),
  473.                                parseInt(r[4], 16), parseInt(r[5], 16),
  474.                                parseInt(r[6], 16), parseInt(r[7], 16));
  475.      }
  476. @@ -166,35 +166,35 @@ UUID.parse = function(strId) {
  477.  };
  478.  
  479.  /**
  480. - * Initializes a {@link UUID} object.
  481. + * Initializes a {@link keplerUUID} object.
  482.   * @private
  483. - * @constructs UUID
  484. + * @constructs keplerUUID
  485.   * @param {number} [timeLow=0] time_low field (octet 0-3, uint32).
  486.   * @param {number} [timeMid=0] time_mid field (octet 4-5, uint16).
  487.   * @param {number} [timeHiAndVersion=0] time_hi_and_version field (octet 6-7, uint16).
  488.   * @param {number} [clockSeqHiAndReserved=0] clock_seq_hi_and_reserved field (octet 8, uint8).
  489.   * @param {number} [clockSeqLow=0] clock_seq_low field (octet 9, uint8).
  490.   * @param {number} [node=0] node field (octet 10-15, uint48).
  491. - * @returns {UUID} this.
  492. + * @returns {keplerUUID} this.
  493.   */
  494. -UUID.prototype._init = function() {
  495. -  var names = UUID.FIELD_NAMES, sizes = UUID.FIELD_SIZES;
  496. -  var bin = UUID._binAligner, hex = UUID._hexAligner;
  497. +keplerUUID.prototype._init = function() {
  498. +  var names = keplerUUID.FIELD_NAMES, sizes = keplerUUID.FIELD_SIZES;
  499. +  var bin = keplerUUID._binAligner, hex = keplerUUID._hexAligner;
  500.  
  501.    /**
  502. -   * UUID internal field values as an array of integers.
  503. +   * keplerUUID internal field values as an array of integers.
  504.     * @type {number[]}
  505.     */
  506.    this.intFields = new Array(6);
  507.  
  508.    /**
  509. -   * UUID internal field values as an array of binary strings.
  510. +   * keplerUUID internal field values as an array of binary strings.
  511.     * @type {string[]}
  512.     */
  513.    this.bitFields = new Array(6);
  514.  
  515.    /**
  516. -   * UUID internal field values as an array of hexadecimal strings.
  517. +   * keplerUUID internal field values as an array of hexadecimal strings.
  518.     * @type {string[]}
  519.     */
  520.    this.hexFields = new Array(6);
  521. @@ -207,7 +207,7 @@ UUID.prototype._init = function() {
  522.    }
  523.  
  524.    /**
  525. -   * UUID version number.
  526. +   * keplerUUID version number.
  527.     * @type {number}
  528.     */
  529.    this.version = (this.intFields.timeHiAndVersion >>> 12) & 0xF;
  530. @@ -233,10 +233,10 @@ UUID.prototype._init = function() {
  531.                   + "-" + this.hexFields[3] + this.hexFields[4] + "-" + this.hexFields[5];
  532.  
  533.    /**
  534. -   * URN string representation ("urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
  535. +   * URN string representation ("urn:keplerUUID:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
  536.     * @type {string}
  537.     */
  538. -  this.urn = "urn:uuid:" + this.hexString;
  539. +  this.urn = "urn:keplerUUID:" + this.hexString;
  540.  
  541.    return this;
  542.  };
  543. @@ -248,7 +248,7 @@ UUID.prototype._init = function() {
  544.   * @param {number} length
  545.   * @returns {string}
  546.   */
  547. -UUID._binAligner = function(num, length) {
  548. +keplerUUID._binAligner = function(num, length) {
  549.    var str = num.toString(2), i = length - str.length, z = "0";
  550.    for (; i > 0; i >>>= 1, z += z) { if (i & 1) { str = z + str; } }
  551.    return str;
  552. @@ -256,57 +256,57 @@ UUID._binAligner = function(num, length) {
  553.  
  554.  /**
  555.   * Returns the hexadecimal string representation.
  556. - * @returns {string} {@link UUID#hexString}.
  557. + * @returns {string} {@link keplerUUID#hexString}.
  558.   */
  559. -UUID.prototype.toString = function() { return this.hexString; };
  560. +keplerUUID.prototype.toString = function() { return this.hexString; };
  561.  
  562.  /**
  563. - * Tests if two {@link UUID} objects are equal.
  564. - * @param {UUID} uuid
  565. - * @returns {boolean} True if two {@link UUID} objects are equal.
  566. + * Tests if two {@link keplerUUID} objects are equal.
  567. + * @param {keplerUUID} keplerUUID
  568. + * @returns {boolean} True if two {@link keplerUUID} objects are equal.
  569.   */
  570. -UUID.prototype.equals = function(uuid) {
  571. -  if (!(uuid instanceof UUID)) { return false; }
  572. +keplerUUID.prototype.equals = function(keplerUUID) {
  573. +  if (!(keplerUUID instanceof keplerUUID)) { return false; }
  574.    for (var i = 0; i < 6; i++) {
  575. -    if (this.intFields[i] !== uuid.intFields[i]) { return false; }
  576. +    if (this.intFields[i] !== keplerUUID.intFields[i]) { return false; }
  577.    }
  578.    return true;
  579.  };
  580.  
  581.  /**
  582. - * Nil UUID object.
  583. - * @type {UUID}
  584. + * Nil keplerUUID object.
  585. + * @type {keplerUUID}
  586.   * @constant
  587.   * @since v3.4.0
  588.   */
  589. -UUID.NIL = new UUID()._init(0, 0, 0, 0, 0, 0);
  590. +keplerUUID.NIL = new keplerUUID()._init(0, 0, 0, 0, 0, 0);
  591.  
  592.  // }}}
  593.  
  594. -// UUID Version 1 Component {{{
  595. +// keplerUUID Version 1 Component {{{
  596.  
  597.  /**
  598. - * Creates a version 1 {@link UUID} object.
  599. - * @returns {UUID} Version 1 {@link UUID} object.
  600. + * Creates a version 1 {@link keplerUUID} object.
  601. + * @returns {keplerUUID} Version 1 {@link keplerUUID} object.
  602.   * @since 3.0
  603.   */
  604. -UUID.genV1 = function() {
  605. -  if (UUID._state == null) { UUID.resetState(); }
  606. -  var now = new Date().getTime(), st = UUID._state;
  607. +keplerUUID.genV1 = function() {
  608. +  if (keplerUUID._state == null) { keplerUUID.resetState(); }
  609. +  var now = new Date().getTime(), st = keplerUUID._state;
  610.    if (now != st.timestamp) {
  611.      if (now < st.timestamp) { st.sequence++; }
  612.      st.timestamp = now;
  613. -    st.tick = UUID._getRandomInt(4);
  614. -  } else if (Math.random() < UUID._tsRatio && st.tick < 9984) {
  615. +    st.tick = keplerUUID._getRandomInt(4);
  616. +  } else if (Math.random() < keplerUUID._tsRatio && st.tick < 9984) {
  617.      // advance the timestamp fraction at a probability
  618.      // to compensate for the low timestamp resolution
  619. -    st.tick += 1 + UUID._getRandomInt(4);
  620. +    st.tick += 1 + keplerUUID._getRandomInt(4);
  621.    } else {
  622.      st.sequence++;
  623.    }
  624.  
  625.    // format time fields
  626. -  var tf = UUID._getTimeFieldValues(st.timestamp);
  627. +  var tf = keplerUUID._getTimeFieldValues(st.timestamp);
  628.    var tl = tf.low + st.tick;
  629.    var thav = (tf.hi & 0xFFF) | 0x1000;  // set version '0001'
  630.  
  631. @@ -315,19 +315,19 @@ UUID.genV1 = function() {
  632.    var cshar = (st.sequence >>> 8) | 0x80; // set variant '10'
  633.    var csl = st.sequence & 0xFF;
  634.  
  635. -  return new UUID()._init(tl, tf.mid, thav, cshar, csl, st.node);
  636. +  return new keplerUUID()._init(tl, tf.mid, thav, cshar, csl, st.node);
  637.  };
  638.  
  639.  /**
  640. - * Re-initializes the internal state for version 1 UUID creation.
  641. + * Re-initializes the internal state for version 1 keplerUUID creation.
  642.   * @since 3.0
  643.   */
  644. -UUID.resetState = function() {
  645. -  UUID._state = new UUIDState();
  646. +keplerUUID.resetState = function() {
  647. +  keplerUUID._state = new keplerUUIDState();
  648.  };
  649.  
  650. -function UUIDState() {
  651. -  var rand = UUID._getRandomInt;
  652. +function keplerUUIDState() {
  653. +  var rand = keplerUUID._getRandomInt;
  654.    this.timestamp = 0;
  655.    this.sequence = rand(14);
  656.    this.node = (rand(8) | 1) * 0x10000000000 + rand(40); // set multicast bit '1'
  657. @@ -339,21 +339,21 @@ function UUIDState() {
  658.   * @private
  659.   * @type {number}
  660.   */
  661. -UUID._tsRatio = 1 / 4;
  662. +keplerUUID._tsRatio = 1 / 4;
  663.  
  664.  /**
  665. - * Persistent internal state for version 1 UUID creation.
  666. + * Persistent internal state for version 1 keplerUUID creation.
  667.   * @private
  668. - * @type {UUIDState}
  669. + * @type {keplerUUIDState}
  670.   */
  671. -UUID._state = null;
  672. +keplerUUID._state = null;
  673.  
  674.  /**
  675.   * @private
  676.   * @param {Date|number} time ECMAScript Date Object or milliseconds from 1970-01-01.
  677.   * @returns {any}
  678.   */
  679. -UUID._getTimeFieldValues = function(time) {
  680. +keplerUUID._getTimeFieldValues = function(time) {
  681.    var ts = time - Date.UTC(1582, 9, 15);
  682.    var hm = ((ts / 0x100000000) * 10000) & 0xFFFFFFF;
  683.    return  { low: ((ts & 0xFFFFFFF) * 10000) % 0x100000000,
  684. @@ -363,15 +363,15 @@ UUID._getTimeFieldValues = function(time) {
  685.  // }}}
  686.  
  687.  // create local namespace
  688. -function UUID() {}
  689. +function keplerUUID() {}
  690.  
  691.  // for nodejs
  692.  if (typeof module === "object" && typeof module.exports === "object") {
  693. -  module.exports = UUID;
  694. +  module.exports = keplerUUID;
  695.  }
  696.  
  697. -return UUID;
  698. +return keplerUUID;
  699.  
  700. -})(UUID);
  701. +})(keplerUUID);
  702.  
  703.  // vim: fdm=marker fmr&
  704. diff --git b/test/kepler_uuid.builder.js a/test/kepler_uuid.builder.js
  705. old mode 100755
  706. new mode 100644
  707. index 2428657..13dd253
  708. --- b/test/kepler_uuid.builder.js
  709. +++ a/test/kepler_uuid.builder.js
  710. @@ -1,8 +1,8 @@
  711. -QUnit.module("UUID.generate()", function() {
  712. +QUnit.module("KepkerUUID.generate()", function() {
  713.    "use strict";
  714.  
  715. -  UUIDTestCommon.testV4AsString(function() {
  716. -    return UUID.generate();
  717. +  KeplerUUIDTestCommon.testV4AsString(function() {
  718. +    return KeplerUUID.generate();
  719.    });
  720.  
  721.  });
  722. diff --git b/test/kepler_uuid.genv1.js a/test/kepler_uuid.genv1.js
  723. old mode 100755
  724. new mode 100644
  725. index 83fe522..0931e0f
  726. --- b/test/kepler_uuid.genv1.js
  727. +++ a/test/kepler_uuid.genv1.js
  728. @@ -1,28 +1,28 @@
  729. -QUnit.module("UUID.genV1() as object", function() {
  730. +QUnit.module("KeplerUUID.genV1() as object", function() {
  731.    "use strict";
  732.  
  733.    QUnit.test("basic object tests", function(assert) {
  734.      var n = 16;
  735.  
  736.      for (var i = 0; i < n; i++) {
  737. -      var uuid = UUID.genV1();
  738. -      assert.equal(uuid.version, 1, "version number field");
  739. +      var KeplerUUID = KeplerUUID.genV1();
  740. +      assert.equal(KeplerUUID.version, 1, "version number field");
  741.  
  742. -      UUIDTestCommon.testObjectProperties(assert, uuid);
  743. +      KeplerUUIDTestCommon.testObjectProperties(assert, KeplerUUID);
  744.      }
  745.    });
  746.  
  747.  });
  748.  
  749.  
  750. -QUnit.module("UUID.genV1() as string", function() {
  751. +QUnit.module("KeplerUUID.genV1() as string", function() {
  752.    "use strict";
  753.  
  754.    var generator = function() {
  755. -    return UUID.genV1().hexString;
  756. +    return KeplerUUID.genV1().hexString;
  757.    };
  758.  
  759. -  UUIDTestCommon.testV1AsString(generator);
  760. +  KeplerUUIDTestCommon.testV1AsString(generator);
  761.  
  762.    QUnit.test("clock sequence tests", function(assert) {
  763.      assert.expect(1024);
  764. @@ -43,9 +43,9 @@ QUnit.module("UUID.genV1() as string", function() {
  765.  
  766.    QUnit.test("node identifier consistency tests", function(assert) {
  767.      assert.expect(48);
  768. -    var n = 4096, uuids = [];
  769. -    for (var i = 0; i < n; i++) { uuids[i] = generator(); }
  770. -    var counts = UUIDTestCommon.countEachBitsOne(uuids);
  771. +    var n = 4096, KeplerUUIDs = [];
  772. +    for (var i = 0; i < n; i++) { KeplerUUIDs[i] = generator(); }
  773. +    var counts = KeplerUUIDTestCommon.countEachBitsOne(KeplerUUIDs);
  774.  
  775.      for (var i = 80; i < 128; i++) {
  776.        var c = counts[i];
  777. @@ -60,21 +60,21 @@ QUnit.module("UUID.genV1() as string", function() {
  778.  });
  779.  
  780.  
  781. -QUnit.module("UUID.genV1() and UUID.resetState()", function() {
  782. +QUnit.module("KeplerUUID.genV1() and KeplerUUID.resetState()", function() {
  783.    "use strict";
  784.  
  785.    var generator = function() {
  786. -    UUID.resetState();
  787. -    return UUID.genV1().hexString;
  788. +    KeplerUUID.resetState();
  789. +    return KeplerUUID.genV1().hexString;
  790.    };
  791.  
  792. -  UUIDTestCommon.testV1AsString(generator);
  793. +  KeplerUUIDTestCommon.testV1AsString(generator);
  794.  
  795.    QUnit.test("random bit neutrality tests (often fail by design)", function(assert) {
  796.      assert.expect(64);
  797. -    var n = 4096, uuids = [];
  798. -    for (var i = 0; i < n; i++) { uuids[i] = generator(); }
  799. -    var counts = UUIDTestCommon.countEachBitsOne(uuids);
  800. +    var n = 4096, KeplerUUIDs = [];
  801. +    for (var i = 0; i < n; i++) { KeplerUUIDs[i] = generator(); }
  802. +    var counts = KeplerUUIDTestCommon.countEachBitsOne(KeplerUUIDs);
  803.      // binom dist middle 99.99% range
  804.      var margin = 3.890592 * Math.sqrt(0.5 * 0.5 / n);
  805.      var ubound = 0.5 + margin, lbound = 0.5 - margin;
  806. diff --git b/test/kepler_uuid.genv4.js a/test/kepler_uuid.genv4.js
  807. old mode 100755
  808. new mode 100644
  809. index e67283d..54eff51
  810. --- b/test/kepler_uuid.genv4.js
  811. +++ a/test/kepler_uuid.genv4.js
  812. @@ -1,24 +1,24 @@
  813. -QUnit.module("UUID.genV4() as object", function() {
  814. +QUnit.module("KeplerUUID.genV4() as object", function() {
  815.    "use strict";
  816.  
  817.    QUnit.test("basic object tests", function(assert) {
  818.      var n = 16;
  819.  
  820.      for (var i = 0; i < n; i++) {
  821. -      var uuid = UUID.genV4();
  822. -      assert.equal(uuid.version, 4, "version number field");
  823. +      var KeplerUUID = KeplerUUID.genV4();
  824. +      assert.equal(KeplerUUID.version, 4, "version number field");
  825.  
  826. -      UUIDTestCommon.testObjectProperties(assert, uuid);
  827. +      KeplerUUIDTestCommon.testObjectProperties(assert, KeplerUUID);
  828.      }
  829.    });
  830.  
  831.  });
  832.  
  833. -QUnit.module("UUID.genV4() as string", function() {
  834. +QUnit.module("KeplerUUID.genV4() as string", function() {
  835.    "use strict";
  836.  
  837. -  UUIDTestCommon.testV4AsString(function() {
  838. -    return UUID.genV4().hexString;
  839. +  KeplerUUIDTestCommon.testV4AsString(function() {
  840. +    return KeplerUUID.genV4().hexString;
  841.    });
  842.  
  843.  });
  844. diff --git b/test/kepler_uuid.nil.js a/test/kepler_uuid.nil.js
  845. old mode 100755
  846. new mode 100644
  847. index be99142..6f513d6
  848. --- b/test/kepler_uuid.nil.js
  849. +++ a/test/kepler_uuid.nil.js
  850. @@ -1,10 +1,10 @@
  851. -QUnit.module("UUID.NIL", function() {
  852. +QUnit.module("KeplerUUID.NIL", function() {
  853.    "use strict";
  854.  
  855. -  QUnit.test("UUID.NIL holds the correct nil UUID object.", function(assert) {
  856. +  QUnit.test("KeplerUUID.NIL holds the correct nil KeplerUUID object.", function(assert) {
  857.      assert.expect(2);
  858. -    assert.strictEqual(UUID.NIL.hexString, "00000000-0000-0000-0000-000000000000", 'UUID.NIL.hexString === "00000000-0000-0000-0000-000000000000"');
  859. -    assert.ok(UUID.NIL.equals(UUID.parse("00000000-0000-0000-0000-000000000000")), 'UUID.NIL.equals(UUID.parse("00000000-0000-0000-0000-000000000000"))');
  860. +    assert.strictEqual(KeplerUUID.NIL.hexString, "00000000-0000-0000-0000-000000000000", 'KeplerUUID.NIL.hexString === "00000000-0000-0000-0000-000000000000"');
  861. +    assert.ok(KeplerUUID.NIL.equals(KeplerUUID.parse("00000000-0000-0000-0000-000000000000")), 'KeplerUUID.NIL.equals(KeplerUUID.parse("00000000-0000-0000-0000-000000000000"))');
  862.    });
  863.  
  864.  });
  865. diff --git b/test/kepler_uuid.parse.js a/test/kepler_uuid.parse.js
  866. old mode 100755
  867. new mode 100644
  868. index 8c96e61..3d38bc9
  869. --- b/test/kepler_uuid.parse.js
  870. +++ a/test/kepler_uuid.parse.js
  871. @@ -1,4 +1,4 @@
  872. -QUnit.module("UUID.parse()", function() {
  873. +QUnit.module("KeplerUUID.parse()", function() {
  874.    "use strict";
  875.  
  876.    QUnit.test("pass tests", function(assert) {
  877. @@ -13,15 +13,15 @@ QUnit.module("UUID.parse()", function() {
  878.        var value = passes[i].canonical = passes[i].value;
  879.        passes.push(
  880.          { canonical: value, value: value.toUpperCase() },
  881. -        { canonical: value, value: "urn:uuid:" + value },
  882. +        { canonical: value, value: "urn:KeplerUUID:" + value },
  883.          { canonical: value, value: "{" + value + "}" },
  884.          { canonical: value, value: "\t  " + value + "\n" }
  885.        );
  886.      }
  887.  
  888.      for (var i = 0, len = passes.length; i < len; i++) {
  889. -      var uuid = UUID.parse(passes[i].value);
  890. -      assert.equal(uuid.hexString, passes[i].canonical, "UUID.parse(\"" + passes[i].value + "\") -> " + uuid.hexString);
  891. +      var KeplerUUID = KeplerUUID.parse(passes[i].value);
  892. +      assert.equal(KeplerUUID.hexString, passes[i].canonical, "KeplerUUID.parse(\"" + passes[i].value + "\") -> " + KeplerUUID.hexString);
  893.      }
  894.    });
  895.  
  896. @@ -39,7 +39,7 @@ QUnit.module("UUID.parse()", function() {
  897.      ];
  898.  
  899.      for (var i = 0, len = fails.length; i < len; i++) {
  900. -      assert.equal(UUID.parse(fails[i]), null, "UUID.parse failed: " + fails[i]);
  901. +      assert.equal(KeplerUUID.parse(fails[i]), null, "KeplerUUID.parse failed: " + fails[i]);
  902.      }
  903.    });
  904.  
  905. diff --git b/test/kepler_uuid.useRandomMath.js a/test/kepler_uuid.useRandomMath.js
  906. old mode 100755
  907. new mode 100644
  908. index 7bbcba6..6e50680
  909. --- b/test/kepler_uuid.useRandomMath.js
  910. +++ a/test/kepler_uuid.useRandomMath.js
  911. @@ -1,10 +1,10 @@
  912. -QUnit.module("UUID.useMathRandom()", function() {
  913. +QUnit.module("KeplerUUID.useMathRandom()", function() {
  914.    "use strict";
  915.  
  916. -  UUID.useMathRandom();
  917. +  KeplerUUID.useMathRandom();
  918.  
  919. -  UUIDTestCommon.testV4AsString(function() {
  920. -    return UUID.generate();
  921. +  KeplerUUIDTestCommon.testV4AsString(function() {
  922. +    return KeplerUUID.generate();
  923.    });
  924.  
  925.  });
  926. diff --git b/test/nodejs.js a/test/nodejs.js
  927. old mode 100755
  928. new mode 100644
  929. index 712ce65..fa52d16
  930. --- b/test/nodejs.js
  931. +++ a/test/nodejs.js
  932. @@ -1,9 +1,9 @@
  933. -global.UUID = require("uuidjs");
  934. -global.UUIDTestCommon = require("./util/uuid-test-common.js");
  935. +global.KeplerUUID = require("kepleruuid.js");
  936. +global.KeplerUUIDTestCommon = require("./util/kepleruuid-test-common.js");
  937.  
  938. -require("./uuid.generate.js");
  939. -require("./uuid.genV4.js");
  940. -require("./uuid.genV1.js");
  941. -require("./uuid.parse.js");
  942. -require("./uuid.nil.js");
  943. -require("./uuid.useMathRandom.js");
  944. +require("./kepler_uuid.builder.js");
  945. +require("./kepler_uuid.genV4.js");
  946. +require("./kepler_uuid.genV1.js");
  947. +require("./kepler_uuid.parse.js");
  948. +require("./kepler_uuid.nil.js");
  949. +require("./kepler_uuid.useMathRandom.js");
  950. diff --git b/types/kepleruuid/index.d.ts a/types/kepleruuid/index.d.ts
  951. old mode 100755
  952. new mode 100644
  953. index b6f00e7..1597af8
  954. --- b/types/kepleruuid/index.d.ts
  955. +++ a/types/kepleruuid/index.d.ts
  956. @@ -1,33 +1,33 @@
  957. -export function generate(): string;
  958. +export function builder(): string;
  959.  
  960. -export function genV4(): UUID;
  961. -export function genV1(): UUID;
  962. -export function parse(strId: string): UUID;
  963. +export function genV4(): KeplerUUID;
  964. +export function genV1(): KeplerUUID;
  965. +export function parse(strId: string): KeplerUUID;
  966.  
  967.  export const FIELD_NAMES: string[];
  968.  export const FIELD_SIZES: number[];
  969. -export const NIL: UUID;
  970. +export const NIL: KeplerUUID;
  971.  
  972. -interface UUID {
  973. -  intFields: UUIDFields<number>;
  974. -  bitFields: UUIDFields<string>;
  975. -  hexFields: UUIDFields<string>;
  976. +interface KeplerUUID {
  977. +  intFields: KeplerUUIDFields<number>;
  978. +  bitFields: KeplerUUIDFields<string>;
  979. +  hexFields: KeplerUUIDFields<string>;
  980.    version: number;
  981.    bitString: string;
  982.    hexNoDelim: string;
  983.    hexString: string;
  984.    urn: string;
  985.    toString(): string;
  986. -  equals(uuid: UUID): boolean;
  987. +  equals(uuid: KeplerUUID): boolean;
  988.  }
  989.  
  990.  export function resetState(): void;
  991.  export function useMathRandom(): void;
  992.  
  993.  // Hide unnecessary methods
  994. -export let overwrittenUUID: any;
  995. +export let overwrittenKeplerUUID: any;
  996.  
  997. -interface UUIDFields<T> extends Array<T> {
  998. +interface KeplerUUIDFields<T> extends Array<T> {
  999.    timeLow: T;
  1000.    timeMid: T;
  1001.    timeHiAndVersion: T;
  1002. diff --git b/types/kepleruuid/kepleruuid_tests.ts a/types/kepleruuid/kepleruuid_tests.ts
  1003. old mode 100755
  1004. new mode 100644
  1005. index 512364e..4150911
  1006. --- b/types/kepleruuid/kepleruuid_tests.ts
  1007. +++ a/types/kepleruuid/kepleruuid_tests.ts
  1008. @@ -1,21 +1,25 @@
  1009. -import * as UUID from 'uuidjs';
  1010. +<<<<<<< HEAD:types/kepleruuid/kepleruuid_tests.ts
  1011. +import * as KeplerUUID from "kepleruuidtest";
  1012. +=======
  1013. +import * as KeplerUUID from 'kepleruuid.js';
  1014. +>>>>>>> development/production:types/kepleruuid_tests.ts
  1015.  
  1016.  const putNum = (x: number) => { console.log(x + ': number') };
  1017.  const putStr = (x: string) => { console.log('"' + x + '": string') };
  1018.  const putBool = (x: boolean) => { console.log(x + ': boolean') };
  1019.  
  1020. -putStr(UUID.generate());
  1021. -let objV4: UUID.UUID = UUID.genV4();
  1022. -let objV1: UUID.UUID = UUID.genV1();
  1023. -let parsed: UUID.UUID = UUID.parse(objV4.toString());
  1024. +putStr(KeplerUUID.generate());
  1025. +let objV4: KeplerUUID.KeplerUUID = KeplerUUID.genV4();
  1026. +let objV1: KeplerUUID.KeplerUUID = KeplerUUID.genV1();
  1027. +let parsed: KeplerUUID.KeplerUUID = KeplerUUID.parse(objV4.toString());
  1028.  
  1029. -let _FIELD_NAMES: Array<string> = UUID.FIELD_NAMES;
  1030. -let _FIELD_SIZES: Array<number> = UUID.FIELD_SIZES;
  1031. -let _NIL: UUID.UUID = UUID.NIL;
  1032. +let _FIELD_NAMES: Array<string> = KeplerUUID.FIELD_NAMES;
  1033. +let _FIELD_SIZES: Array<number> = KeplerUUID.FIELD_SIZES;
  1034. +let _NIL: KeplerUUID.KeplerUUID = KeplerUUID.NIL;
  1035.  
  1036. -let _intFields: UUID.UUIDFields<number> = objV4.intFields;
  1037. -let _bitFields: UUID.UUIDFields<string> = objV4.bitFields;
  1038. -let _hexFields: UUID.UUIDFields<string> = objV4.hexFields;
  1039. +let _intFields: KeplerUUID.KeplerUUIDFields<number> = objV4.intFields;
  1040. +let _bitFields: KeplerUUID.KeplerUUIDFields<string> = objV4.bitFields;
  1041. +let _hexFields: KeplerUUID.KeplerUUIDFields<string> = objV4.hexFields;
  1042.  
  1043.  for (let i: number = 0; i < 6; i++) {
  1044.    putNum(_intFields[i]);
  1045. @@ -50,5 +54,5 @@ putStr(objV4.urn);
  1046.  putStr(objV4.toString());
  1047.  putBool(objV4.equals(objV1));
  1048.  
  1049. -UUID.resetState();
  1050. -UUID.useMathRandom();
  1051. +KeplerUUID.resetState();
  1052. +KeplerUUID.useMathRandom();
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!