braid-text 0.0.27 → 0.0.29

package/index.js

@@ -5,6 +5,7 @@ let fs = require("fs")
 
 let braid_text = {
     db_folder: './braid-text-db',
+    length_cache_size: 10,
     cache: {}
 }
 
@@ -252,12 +253,10 @@ braid_text.get = async (key, options) => {
                     body: "",
                 })
 
-                updates = OpLog_get_patches(resource.doc.toBytes(), resource.doc.getOpsSince([]))
+                updates = dt_get_patches(resource.doc)
             } else {
                 // Then start the subscription from the parents in options
-                let local_version = OpLog_remote_to_local(resource.doc, options.parents || options.version)
-
-                updates = OpLog_get_patches(resource.doc.getPatchSince(local_version), resource.doc.getOpsSince(local_version))
+                updates = dt_get_patches(resource.doc, options.parents || options.version)
             }
 
             for (let u of updates) {
@@ -303,10 +302,10 @@ braid_text.put = async (key, options) => {
     let parents = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
     let og_parents = options_parents || parents
 
-    let max_pos = count_code_points(v_eq(parents, og_parents) ?
-        resource.doc.get() :
-        dt_get(resource.doc, og_parents).get())
-
+    let max_pos = resource.length_cache.get('' + og_parents) ??
+        (v_eq(parents, og_parents) ? resource.doc.len() :
+            dt_get(resource.doc, og_parents).len())
+    
     if (body != null) {
         patches = [{
             unit: 'text',
@@ -343,8 +342,7 @@ braid_text.put = async (key, options) => {
         if (!options.validate_already_seen_versions) return
 
         // if we have seen it already, make sure it's the same as before
-        let local_version = OpLog_remote_to_local(resource.doc, og_parents)
-        let updates = OpLog_get_patches(resource.doc.getPatchSince(local_version), resource.doc.getOpsSince(local_version))
+        let updates = dt_get_patches(resource.doc, og_parents)
 
         let seen = {}
         for (let u of updates) {
@@ -403,6 +401,10 @@ braid_text.put = async (key, options) => {
     }
     resource.actor_seqs[v[0]] = v[1]
 
+    resource.length_cache.put(`${v[0]}-${v[1]}`, patches.reduce((a, b) =>
+        a + (b.content.length ? b.content.length : -(b.range[1] - b.range[0])),
+        max_pos))
+
     v = `${v[0]}-${v[1] + 1 - change_count}`
 
     let ps = og_parents
@@ -415,7 +417,7 @@ braid_text.put = async (key, options) => {
     for (let p of patches) {
         // delete
         for (let i = p.range[0]; i < p.range[1]; i++) {
-            bytes.push(OpLog_create_bytes(v, ps, p.range[1] - 1 + offset, null))
+            bytes.push(dt_create_bytes(v, ps, p.range[1] - 1 + offset, null))
             offset--
             ps = [v]
             v = decode_version(v)
@@ -424,7 +426,7 @@ braid_text.put = async (key, options) => {
         // insert
         for (let i = 0; i < p.content?.length ?? 0; i++) {
             let c = p.content[i]
-            bytes.push(OpLog_create_bytes(v, ps, p.range[1] + offset, c))
+            bytes.push(dt_create_bytes(v, ps, p.range[1] + offset, c))
             offset++
             ps = [v]
             v = decode_version(v)
@@ -584,6 +586,8 @@ async function get_resource(key) {
 
         resource.val = resource.doc.get()
 
+        resource.length_cache = createSimpleCache(braid_text.length_cache_size)
+
         done(resource)
     })
     return await cache[key]
@@ -764,31 +768,30 @@ async function file_sync(key, process_delta, get_init) {
 //////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////
 
-function dt_get(doc, version) {
+function dt_get(doc, version, agent = null) {
+    let bytes = doc.toBytes()
+    dt_get.last_doc = doc = Doc.fromBytes(bytes, agent)
+
+    let [_agents, versions, parentss] = dt_parse([...bytes])
+
     let frontier = {}
-    version.forEach((x) => (frontier[x] = true))
+    version.forEach((x) => frontier[x] = true)
 
     let local_version = []
-    let [agents, versions, parentss] = parseDT([...doc.toBytes()])
-    for (let i = 0; i < versions.length; i++) {
-        if (frontier[versions[i].join("-")]) {
-            local_version.push(i)
-        }
-    }
-    local_version = new Uint32Array(local_version)
+    for (let i = 0; i < versions.length; i++)
+        if (frontier[versions[i].join("-")]) local_version.push(i)
+    dt_get.last_local_version = local_version = new Uint32Array(local_version)
 
     let after_versions = {}
-    let [_, after_versions_array, __] = parseDT([...doc.getPatchSince(local_version)])
+    let [_, after_versions_array, __] = dt_parse([...doc.getPatchSince(local_version)])
     for (let v of after_versions_array) after_versions[v.join("-")] = true
 
-    let new_doc = new Doc()
+    let new_doc = new Doc(agent)
     let op_runs = doc.getOpsSince([])
+
     let i = 0
     op_runs.forEach((op_run) => {
-        let parents = parentss[i].map((x) => x.join("-"))
-        let start = op_run.start
-        let end = start + 1
-        let content = op_run.content?.[0]
+        if (op_run.content) op_run.content = [...op_run.content]
 
         let len = op_run.end - op_run.start
         let base_i = i
@@ -804,38 +807,48 @@ function dt_get(doc, version) {
             ) {
                 for (; i < I; i++) {
                     let version = versions[i].join("-")
-                    if (!after_versions[version]) {
-                        new_doc.mergeBytes(
-                            OpLog_create_bytes(
-                                version,
-                                parentss[i].map((x) => x.join("-")),
-                                content ? start + (i - base_i) : start,
-                                content?.[0]
-                            )
+                    if (!after_versions[version]) new_doc.mergeBytes(
+                        dt_create_bytes(
+                            version,
+                            parentss[i].map((x) => x.join("-")),
+                            op_run.fwd ?
+                                (op_run.content ?
+                                    op_run.start + (i - base_i) :
+                                    op_run.start) :
+                                op_run.end - 1 - (i - base_i),
+                            op_run.content?.[i - base_i]
                         )
-                    }
-                    if (op_run.content) content = content.slice(1)
+                    )
                 }
-                content = ""
             }
-            if (op_run.content) content += op_run.content[j]
         }
     })
     return new_doc
 }
 
-function defrag_dt(doc) {
-    let fresh_doc = new Doc("server")
-    fresh_doc.mergeBytes(doc.toBytes())
-    return fresh_doc
-}
+function dt_get_patches(doc, version = null) {
+    let bytes = doc.toBytes()
+    doc = Doc.fromBytes(bytes)
+
+    let [_agents, versions, parentss] = dt_parse([...bytes])
 
-function OpLog_get_patches(bytes, op_runs) {
-    //   console.log(`op_runs = `, op_runs);
+    let op_runs = []
+    if (version) {
+        let frontier = {}
+        version.forEach((x) => frontier[x] = true)
+        let local_version = []
+        for (let i = 0; i < versions.length; i++)
+            if (frontier[versions[i].join("-")]) local_version.push(i)
+        let after_bytes = doc.getPatchSince(new Uint32Array(local_version))
 
-    let [agents, versions, parentss] = parseDT([...bytes])
+        ;[_agents, versions, parentss] = dt_parse([...after_bytes])
 
-    //   console.log(JSON.stringify({agents, versions, parentss}, null, 4))
+        let before_doc = dt_get(doc, version)
+        let before_doc_frontier = before_doc.getLocalVersion()
+
+        before_doc.mergeBytes(after_bytes)
+        op_runs = before_doc.getOpsSince(before_doc_frontier)
+    } else op_runs = doc.getOpsSince([])
 
     let i = 0
     let patches = []
@@ -845,11 +858,11 @@ function OpLog_get_patches(bytes, op_runs) {
         let start = op_run.start
         let end = start + 1
         if (op_run.content) op_run.content = [...op_run.content]
-        let content = op_run.content?.[0]
         let len = op_run.end - op_run.start
         for (let j = 1; j <= len; j++) {
             let I = i + j
             if (
+                (!op_run.content && op_run.fwd) ||
                 j == len ||
                 parentss[I].length != 1 ||
                 parentss[I][0][0] != versions[I - 1][0] ||
@@ -857,30 +870,38 @@ function OpLog_get_patches(bytes, op_runs) {
                 versions[I][0] != versions[I - 1][0] ||
                 versions[I][1] != versions[I - 1][1] + 1
             ) {
+                let s = op_run.fwd ?
+                    (op_run.content ?
+                        start :
+                        op_run.start) :
+                    (op_run.start + (op_run.end - end))
+                let e = op_run.fwd ?
+                    (op_run.content ?
+                        end :
+                        op_run.start + (end - start)) :
+                    (op_run.end - (start - op_run.start))
                 patches.push({
                     version,
                     parents,
                     unit: "text",
-                    range: content ? `[${start}:${start}]` : `[${start}:${end}]`,
-                    content: content ?? "",
-                    start,
-                    end,
+                    range: op_run.content ? `[${s}:${s}]` : `[${s}:${e}]`,
+                    content: op_run.content?.slice(start - op_run.start, end - op_run.start).join("") ?? "",
+                    start: s,
+                    end: e,
                 })
                 if (j == len) break
                 version = versions[I].join("-")
                 parents = parentss[I].map((x) => x.join("-")).sort()
                 start = op_run.start + j
-                content = ""
             }
             end++
-            if (op_run.content) content += op_run.content[j]
         }
         i += len
     })
     return patches
 }
 
-function parseDT(byte_array) {
+function dt_parse(byte_array) {
     if (new TextDecoder().decode(new Uint8Array(byte_array.splice(0, 8))) !== "DMNDTYPS") throw new Error("dt parse error, expected DMNDTYPS")
 
     if (byte_array.shift() != 0) throw new Error("dt parse error, expected version 0")
@@ -975,8 +996,7 @@ function parseDT(byte_array) {
     return [agents, versions, parentss]
 }
 
-function OpLog_create_bytes(version, parents, pos, ins) {
-    // console.log(`args = ${JSON.stringify({ version, parents, pos, ins }, null, 4)}`)
+function dt_create_bytes(version, parents, pos, ins) {
 
     function write_varint(bytes, value) {
         while (value >= 0x80) {
@@ -1122,6 +1142,10 @@ function OpLog_create_bytes(version, parents, pos, ins) {
     return bytes
 }
 
+function defrag_dt(doc) {
+    return Doc.fromBytes(doc.toBytes(), 'server')
+}
+
 function OpLog_remote_to_local(doc, frontier) {
     let map = Object.fromEntries(frontier.map((x) => [x, true]))
 
@@ -1496,7 +1520,46 @@ function validate_patch(x) {
     if (typeof x.content !== 'string') throw new Error(`invalid patch content: must be a string`)
 }
 
+function createSimpleCache(size) {
+    const maxSize = size
+    const cache = new Map()
+
+    return {
+        put(key, value) {
+            if (cache.has(key)) {
+                // If the key already exists, update its value and move it to the end
+                cache.delete(key)
+                cache.set(key, value)
+            } else {
+                // If the cache is full, remove the oldest entry
+                if (cache.size >= maxSize) {
+                    const oldestKey = cache.keys().next().value
+                    cache.delete(oldestKey)
+                }
+                // Add the new key-value pair
+                cache.set(key, value)
+            }
+        },
+
+        get(key) {
+            if (!cache.has(key)) {
+                return null
+            }
+            // Move the accessed item to the end (most recently used)
+            const value = cache.get(key)
+            cache.delete(key)
+            cache.set(key, value)
+            return value
+        },
+    }
+}
+
 braid_text.encode_filename = encode_filename
 braid_text.decode_filename = decode_filename
 
+braid_text.dt_get = dt_get
+braid_text.dt_get_patches = dt_get_patches
+braid_text.dt_parse = dt_parse
+braid_text.dt_create_bytes = dt_create_bytes
+
 module.exports = braid_text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braidjs",

package/server-demo.js

@@ -64,7 +64,7 @@ var server = require("http").createServer(async (req, res) => {
     // }
 
     // Create some initial text for new documents
-    if (await braid_text.get(req.url) === undefined) {
+    if (!(await braid_text.get(req.url, {})).version.length) {
         await braid_text.put(req.url, {body: 'This is a fresh blank document, ready for you to edit.' })
     }
 

package/test.js

@@ -0,0 +1,476 @@
+
+let { Doc } = require("diamond-types-node")
+let {dt_get, dt_get_patches, dt_parse, dt_create_bytes} = require('./index.js')
+
+async function main() {
+    let best_seed = 0
+    let best_n = Infinity
+    let base = Math.floor(Math.random() * 10000000)
+
+    let og_log = console.log
+    console.log = () => {}
+    for (let t = 0; t < 10000; t++) {
+        let seed = base + t
+    // for (let t = 0; t < 10; t++) {
+    //     let seed = 1188661 + t
+
+        og_log(`t = ${t}, seed = ${seed}, best_n = ${best_n} @ ${best_seed}`)
+        Math.randomSeed(seed)
+
+        let n = Math.floor(Math.random() * 15)
+        console.log(`n = ${n}`)
+
+        try {
+            // 1. create a bunch of edits to a dt
+            let doc = new Doc('server')
+
+            let middle_doc = null
+
+            if (!middle_doc && (Math.random() < 1/n || n == 0)) {
+                middle_doc = Doc.fromBytes(doc.toBytes())
+            }
+            for (let i = 0; i < n; i++) {
+                make_random_edit(doc)
+
+                if (!middle_doc && (Math.random() < 1/n || i == n - 1)) {
+                    middle_doc = Doc.fromBytes(doc.toBytes())
+                }
+            }
+            if (!middle_doc) throw 'bad'
+
+            // 2. let x = the resulting string
+            let x = doc.get()
+            console.log('x = ' + x)
+
+            // // 3. use the code for sending these edits over the wire to create a new dt
+            let updates = dt_get_patches(doc)
+            console.log(updates)
+
+            let new_doc = new Doc('server')
+            apply_updates(new_doc, updates)
+            let y = new_doc.get()
+            console.log('y = ' + y)
+
+            // 4. is the resulting string == x?
+            console.log(x == y)
+            if (x != y && n < best_n) {
+                best_n = n
+                best_seed = seed
+            }
+
+            // 5. test dt_get
+            let middle_v = middle_doc.getRemoteVersion().map(x => x.join('-'))
+            let new_middle_doc = dt_get(doc, middle_v)
+            console.log('new_middle_doc = ' + new_middle_doc.get())
+            if (middle_doc.get() != new_middle_doc.get() && n < best_n) {
+                best_n = n
+                best_seed = seed
+            }
+
+            // 6. test dt_get_patches(doc, version)
+            if (true) {
+                let updates = dt_get_patches(doc, middle_v)
+                console.log(`updates:`, updates)
+
+                apply_updates(middle_doc, updates)
+                console.log(`middle_doc2:${middle_doc.get()}`)
+                if (middle_doc.get() != doc.get() && n < best_n) {
+                    best_n = n
+                    best_seed = seed
+                }
+            }
+
+            // 7. try applying a patch that's out of range..
+            // if (true) {
+            //     let agent = Math.random().toString(36).slice(2)
+            //     let parents = doc.getRemoteVersion().map(x => x.join('-'))
+            //     let len = doc.len()
+            //     let args = [`${agent}-0`, parents, len + 1, 'c']
+            //     console.log('ARGS:', args)
+            //     try {
+            //         doc.mergeBytes(dt_create_bytes(...args))
+            //     } catch (e) {
+            //         console.log(`EEEE = ${e}`)
+            //     }
+            //     console.log('did that..')
+            // }
+        } catch (e) {
+            if (console.log == og_log) throw e
+            if (n < best_n) {
+                best_n = n
+                best_seed = seed
+            }
+        }
+    }
+    og_log(`best_seed = ${best_seed}, best_n = ${best_n}`)
+}
+
+function make_random_edit(doc) {
+    let [agents, versions, _parentss] = dt_parse([...doc.toBytes()])
+
+    let agent = (agents.length && Math.random() > 0.5) ?
+        agents[Math.floor(Math.random() * agents.length)] :
+        Math.random().toString(36).slice(2)
+
+    let include_versions = []
+    let base_seq = -1
+    for (let i = 0; i < versions.length; i++) {
+        let [a, seq] = versions[i]
+        if (a == agent || Math.random() > 0.5) {
+            include_versions.push(a + '-' + seq)
+            if (a == agent && seq > base_seq) base_seq = seq
+        }
+    }
+    base_seq++
+
+    console.log({agents, versions, include_versions})
+
+    let parent_doc = dt_get(doc, include_versions)
+
+    let parents = parent_doc.getRemoteVersion().map(x => x.join('-'))
+
+    let len = parent_doc.len()
+    console.log(`len = ${len}`)
+
+    if (len && Math.random() > 0.5) {
+        // delete
+        let start = Math.floor(Math.random() * len)
+        let del_len = Math.floor(Math.random() * (len - start - 1)) + 1
+
+        for (let i = 0; i < del_len; i++) {
+            let v = `${agent}-${base_seq++}`
+            let args = [v, parents, start + del_len - 1 - i, null]
+            console.log(args)
+            doc.mergeBytes(dt_create_bytes(...args))
+            parents = [v]
+        }
+    } else {
+        // insert
+        let start = Math.floor(Math.random() * (len + 1))
+        let ins_len = Math.floor(Math.random() * 10) + 1
+
+        for (let i = 0; i < ins_len; i++) {
+            let v = `${agent}-${base_seq++}`
+            let args = [v, parents, start++, getRandomCharacter()]
+            console.log(args)
+            doc.mergeBytes(dt_create_bytes(...args))
+            parents = [v]
+        }
+    }
+
+    // work here
+    console.log(`doc => ${doc.get()}`)
+}
+
+function apply_updates(doc, updates) {
+    for (let u of updates) {
+        u.range = u.range.match(/\d+/g).map((x) => parseInt(x))
+        u.content = [...u.content]
+
+        let v = u.version
+        let ps = u.parents
+
+        console.log('UPDATE:', u)
+
+        // delete
+        for (let i = u.range[1] - 1; i >= u.range[0]; i--) {
+
+            // work here
+            let args = [v, ps, i, null]
+            console.log(`args`, args)
+
+            doc.mergeBytes(dt_create_bytes(...args))
+            ps = [v]
+            v = decode_version(v)
+            v = `${v[0]}-${v[1] + 1}`
+        }
+        // insert
+        for (let i = 0; i < u.content?.length ?? 0; i++) {
+            let c = u.content[i]
+
+            // work here
+            let args = [v, ps, u.range[0] + i, c]
+            console.log(`args`, args)
+
+            doc.mergeBytes(dt_create_bytes(...args))
+            ps = [v]
+            v = decode_version(v)
+            v = `${v[0]}-${v[1] + 1}`
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+
+function getRandomCharacter() {
+    const characters = [
+        // ASCII characters
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+        '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '+', '=',
+
+        // Unicode characters (each is a single code point)
+        'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ', // Greek letters
+        '零', '一', '二', '三', '四', '五', '六', '七', // Chinese numerals
+        '☀', '☁', '☂', '☃', '☄', '★', '☆', '☇', // Miscellaneous symbols
+        '🌈', '🌞', '🌝', '🌚', '🌕', '🌖', '🌗', '🌘', // Emoji (may be multiple UTF-16 units)
+        'Ω', 'π', '∑', '√', '∫', '∀', '∂', '∃', // Mathematical symbols
+        'あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', // Japanese Hiragana
+        'ا', 'ب', 'ت', 'ث', 'ج', 'ح', 'خ', 'د', // Arabic letters
+    ];
+
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    return characters[randomIndex];
+}
+
+function decode_version(v) {
+    let m = v.match(/^(.*)-(\d+)$/s)
+    if (!m) throw new Error(`invalid actor-seq version: ${v}`)
+    return [m[1], parseInt(m[2])]
+}
+
+/////////
+
+// the next two functions added by me
+
+function create_rand(seed) {
+    if (typeof (seed) == 'string') {
+        var t = new MersenneTwister(0)
+        var a = []
+        for (var i = 0; i < seed.length; i++)
+            a[i] = seed.charCodeAt(i)
+        t.init_by_array(a, a.length)
+    } else if (typeof (seed) == 'number') {
+        var t = new MersenneTwister(seed)
+    } else {
+        var t = new MersenneTwister()
+    }
+    return () => t.random()
+}
+
+Math.randomSeed = function (seed) {
+    var r = create_rand(seed)
+    Math.random = () => r()
+}
+
+/* The following piece of code is an implementation of MersenneTwister object
+   taken from https://gist.github.com/banksean/300494, with one method 
+   xor_array(array, size) added.
+*/
+
+/*
+  I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
+  so it's better encapsulated. Now you can have multiple random number generators
+  and they won't stomp all over eachother's state.
+  
+  If you want to use this as a substitute for Math.random(), use the random()
+  method like so:
+  
+  var m = new MersenneTwister();
+  var randomNumber = m.random();
+  
+  You can also call the other genrand_{foo}() methods on the instance.
+
+  If you want to use a specific seed in order to get a repeatable random
+  sequence, pass an integer into the constructor:
+
+  var m = new MersenneTwister(123);
+
+  and that will always produce the same random sequence.
+
+  Sean McCullough (banksean@gmail.com)
+*/
+
+/* 
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+ 
+   Before using, initialize the state by using init_genrand(seed)  
+   or init_by_array(init_key, key_length).
+ 
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.                          
+ 
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+ 
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+ 
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+ 
+     3. The names of its contributors may not be used to endorse or promote 
+        products derived from this software without specific prior written 
+        permission.
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ 
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+var MersenneTwister = function (seed) {
+    if (seed == undefined) {
+        seed = new Date().getTime();
+    }
+    /* Period parameters */
+    this.N = 624;
+    this.M = 397;
+    this.MATRIX_A = 0x9908b0df;   /* constant vector a */
+    this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
+    this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
+
+    this.mt = new Array(this.N); /* the array for the state vector */
+    this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
+
+    this.init_genrand(seed);
+}
+
+/* initializes mt[N] with a seed */
+MersenneTwister.prototype.init_genrand = function (s) {
+    this.mt[0] = s >>> 0;
+    for (this.mti = 1; this.mti < this.N; this.mti++) {
+        var s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
+        this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
+            + this.mti;
+        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+        /* In the previous versions, MSBs of the seed affect   */
+        /* only MSBs of the array mt[].                        */
+        /* 2002/01/09 modified by Makoto Matsumoto             */
+        this.mt[this.mti] >>>= 0;
+        /* for >32 bit machines */
+    }
+}
+
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
+    var i, j, k;
+    this.init_genrand(19650218);
+    i = 1; j = 0;
+    k = (this.N > key_length ? this.N : key_length);
+    for (; k; k--) {
+        var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)
+        this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
+            + init_key[j] + j; /* non linear */
+        this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+        i++; j++;
+        if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
+        if (j >= key_length) j = 0;
+    }
+    for (k = this.N - 1; k; k--) {
+        var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+        this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
+            - i; /* non linear */
+        this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+        i++;
+        if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
+    }
+
+    this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
+}
+
+/* XORs the mt array with a given array xor_key of length key_length */
+MersenneTwister.prototype.xor_array = function (xor_key, key_length) {
+    var i, j;
+    j = 0;
+    for (i = 0; i < this.N; i++) {
+        this.mt[i] ^= xor_key[j];
+        this.mt[i] >>>= 0;
+        j++;
+        if (j >= key_length) j = 0;
+    }
+}
+
+/* generates a random number on [0,0xffffffff]-interval */
+MersenneTwister.prototype.genrand_int32 = function () {
+    var y;
+    var mag01 = new Array(0x0, this.MATRIX_A);
+    /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+    if (this.mti >= this.N) { /* generate N words at one time */
+        var kk;
+
+        if (this.mti == this.N + 1)   /* if init_genrand() has not been called, */
+            this.init_genrand(5489); /* a default initial seed is used */
+
+        for (kk = 0; kk < this.N - this.M; kk++) {
+            y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+            this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
+        }
+        for (; kk < this.N - 1; kk++) {
+            y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+            this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
+        }
+        y = (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
+        this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
+
+        this.mti = 0;
+    }
+
+    y = this.mt[this.mti++];
+
+    /* Tempering */
+    y ^= (y >>> 11);
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= (y >>> 18);
+
+    return y >>> 0;
+}
+
+/* generates a random number on [0,0x7fffffff]-interval */
+MersenneTwister.prototype.genrand_int31 = function () {
+    return (this.genrand_int32() >>> 1);
+}
+
+/* generates a random number on [0,1]-real-interval */
+MersenneTwister.prototype.genrand_real1 = function () {
+    return this.genrand_int32() * (1.0 / 4294967295.0);
+    /* divided by 2^32-1 */
+}
+
+/* generates a random number on [0,1)-real-interval */
+MersenneTwister.prototype.random = function () {
+    return this.genrand_int32() * (1.0 / 4294967296.0);
+    /* divided by 2^32 */
+}
+
+/* generates a random number on (0,1)-real-interval */
+MersenneTwister.prototype.genrand_real3 = function () {
+    return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
+    /* divided by 2^32 */
+}
+
+/* generates a random number on [0,1) with 53-bit resolution*/
+MersenneTwister.prototype.genrand_res53 = function () {
+    var a = this.genrand_int32() >>> 5, b = this.genrand_int32() >>> 6;
+    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+}
+
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
+
+////////////////////////////////////////////////////////////////////
+main()