doubledepth

var Bitwise = function () {};
Bitwise.prototype.p = (function () {
    var a = [];
    var i = 0;
    while (i < 33) {
        a.push(Math.pow(2, i)); // 2 ** i
        i += 1;
    }
    return a;
}());
Bitwise.prototype.toInt32 = function (x) {
    var n = Number(x);
    var neg;
    if (!isFinite(n) || n === 0) { // for IE
    //if (!Number.isFinite(n) || n === 0) {
        return 0;
    }
    if (n < 0) {
        neg = true;
        n = -n;
    }
    n = Math.floor(n) % this.p[32];
    if (n > this.p[31]) {
        n -= this.p[32];
    }
    return (
        neg
        ? -n
        : n
    );
};
Bitwise.prototype.toUint32 = function (x) {
    var n = Number(x);
    var neg;
    if (!isFinite(n) || n === 0) { // for IE
    //if (!Number.isFinite(n) || n === 0) {
        return 0;
    }
    if (n < 0) {
        neg = true;
        n = -n;
    }
    n = Math.floor(n);
    if (neg) {
        n = -n;
    }
    n = n % this.p[32];
    return (
        (n < 0)
        ? this.p[32] + n
        : n
    );
};
Bitwise.prototype.toBinary = function (int32) {
    var a = [];
    var i = 0;
    var p = int32;
    var neg;
    var carry;
    if (p < 0) {
        neg = true;
        p = -p;
    }
    while (p >= 2) {
        a[i] = p % 2;
        i += 1;
        p = Math.floor(p / 2);
    }
    a[i] = p;
    i += 1;
    while (i < 32) {
        a[i] = 0;
        i += 1;
    }
    if (!neg) {
        return a;
    }
    i = 0;
    while (i < 32) {
        a[i] = Number(!a[i]);
        i += 1;
    }
    a[32] = 0;
    i = 0;
    do {
        carry = a[i];
        a[i] = Number(!a[i]);
        i += 1;
    } while (carry);
    a.pop();
    return a;
};
Bitwise.prototype.not = function (num) {
    var a = this.toBinary(this.toInt32(num));
    var i = 32;
    var n = 0;
    var p = this.p;
    while (i) {
        i -= 1;
        n += p[i] * Number(!a[i]);
    }
    return this.toInt32(n);
};
Bitwise.prototype.and = function (l, r) {
    var L = this.toBinary(this.toInt32(l));
    var R = this.toBinary(this.toInt32(r));
    var p = this.p;
    var i = 32;
    var n = 0;
    while (i) {
        i -= 1;
        n += p[i] * Number(L[i] && R[i]);
    }
    return this.toInt32(n);
};
Bitwise.prototype.or = function (l, r) {
    var L = this.toBinary(this.toInt32(l));
    var R = this.toBinary(this.toInt32(r));
    var p = this.p;
    var i = 32;
    var n = 0;
    while (i) {
        i -= 1;
        n += p[i] * Number(L[i] || R[i]);
    }
    return this.toInt32(n);
};
Bitwise.prototype.xor = function (l, r) {
    var L = this.toBinary(this.toInt32(l));
    var R = this.toBinary(this.toInt32(r));
    var p = this.p;
    var i = 32;
    var n = 0;
    while (i) {
        i -= 1;
        n += p[i] * Number(L[i] !== R[i]);
    }
    return this.toInt32(n);
};
Bitwise.prototype.leftShift = function (l, r) {
    var L = this.toBinary(this.toInt32(l));
    var R = this.and(this.toUint32(r), 31);
    var p = this.p;
    var n = 0;
    var i = 0;
    var B = [];
    // L = new Array(R).fill(0).concat(L).slice(0, 32);
    while (i < R) {
        B[i] = 0;
        i += 1;
    }
    while (i < 32) {
        B[i] = L[i - R];
        i += 1;
    }
    while (i) {
        i -= 1;
        n += p[i] * B[i];
    }
    return this.toInt32(n);
};
Bitwise.prototype.rightShift = function (l, r) {
    var L = this.toBinary(this.toInt32(l));
    var R = this.and(this.toUint32(r), 31);
    var p = this.p;
    var n = 0;
    // L = L.concat(new Array(R).fill(L[31])).slice(-32);
    var B = [];
    var padd = L[31];
    var i = R;
    while (i < 32) {
        B[i - R] = L[i];
        i += 1;
    }
    i = B.length;
    while (i < 32) {
        B[i] = padd;
        i += 1;
    }
    while (i) {
        i -= 1;
        n += p[i] * B[i];
    }
    return this.toInt32(n);
};
Bitwise.prototype.unsignedRightShift = function (l, r) {
    var L = this.toBinary(this.toUint32(l));
    var R = this.and(this.toUint32(r), 31);
    var p = this.p;
    var n = 0;
    // L = L.concat(new Array(R).fill(0)).slice(-32);
    var B = [];
    var i = R;
    while (i < 32) {
        B[i - R] = L[i];
        i += 1;
    }
    i = B.length;
    while (i < 32) {
        B[i] = 0;
        i += 1;
    }
    while (i) {
        i -= 1;
        n += p[i] * B[i];
    }
    return this.toUint32(n);
};


if (typeof Object.create !== "function") {
    Object.create = function (proto) {
        var F = function () {};
        F.prototype = proto;
        return new F();
    };
}


var Random = function (seed) {
    this.x = 123456789;
    this.y = 362436069;
    this.z = 521288629;
    this.w = seed || 88675123;
};

//Object.assign(Random.prototype, Bitwise);
Random.prototype = Object.create(Bitwise.prototype);

Random.prototype.next = function () { // Xorshift128
    var t = this.xor(this.x, this.leftShift(this.x, 11));
    this.x = this.y;
    this.y = this.z;
    this.z = this.w;
    this.w = this.xor(
        this.xor(this.w, this.unsignedRightShift(this.w, 19)),
        this.xor(t, this.unsignedRightShift(t, 8))
    );
    return this.w;
};
Random.prototype.nextInt = function (min, max) { // from min to max
    return min + (Math.abs(this.next()) % (max + 1 - min));
};

Bitwise classは元々ただのobjectをObject.assign()していたが、Internet Explorerで使えなかったのでObject.create()に変更した。共通部分を別関数に切り出していた箇所は、inliningによって400 msくらい速くなった。効果がその程度ならinliningしないほうが良さそう。

元の愚鈍な文字列操作版からは2.5倍から8倍ほど高速化することができたが、Firefoxはまだ遅い。ここからさらに高速化するにはどうすればいいだろうか。私に思いつけたのは配列を使う素朴な方法だけだったが、その配列がなんか遅いというか、根本的に（私が）賢くないというか、もっといけてるalgorithmがありそう。あとは真偽値だけを使うことで実行時最適化に期待する、とかだろうか。

const Random = function (seed = 88675123) {
    this.x = Uint32Array.of(123456789, 362436069, 521288629, seed, 0);
};
Random.prototype.next = function () { // Xorshift128
    this.x[4] = this.x[0] ^ (this.x[0] << 11);
    this.x.copyWithin(0, 1, 4);
    this.x[3] = (this.x[3] ^ (this.x[3] >>> 19)) ^ (this.x[4] ^ (this.x[4] >>> 8));
    return this.x[3];
};
Random.prototype.nextInt = function (min, max) { // from min to max
    return min + (Math.abs(this.next()) % (max + 1 - min));
};

Xorshift128、「行列内容を全部0にするのは厳禁」だが、それ以外なら何でもいいらしい。そこは変更する理由はないのでseedはそのままにした。計算途中の一時的な値もTypedArrayの外に出した時点でtoInt32が適用されてしまうらしいので、元の一時変数tはTypedArray要素に置き換えた。

bitwise.not(-1234567.89);                   // 1234566
bitwise.and(-1234, -567.89);                //   -1784
bitwise.or(-1234, -567.89);                 //     -17
bitwise.xor(-1234, -567.89);                //    1767
bitwise.leftShift(-1234, -567.89);          // -631808
bitwise.rightShift(-1234, -567.89);         //      -3
bitwise.unsignedRightShift(-1234, -567.89); // 8388605

文字列を使わず数値型のままbitmaskとやらを行えば、たぶん10倍以上高速化できそうな気がするが、実用性が皆無とわかりきっているもどきにこれ以上手を入れるのはさすがに不毛かな〜

<!DOCTYPE html>
<meta charset="utf-8">
<title>JSON nest3104</title>
<style>
pre {
    inline-size: 100%;
    white-space: pre-wrap;
}
</style>
<body>
<h1>JSON nest3104</h1>
<pre id="TEST"></pre>
<script>
var getProperty = function (object, propertyPath) {
    // https://qiita.com/standard-software/items/bb044217d0a4b394b8e2
    if (!object) {
        return undefined;
    }
    var result = object;
    var propertyArray = propertyPath.slice(1, -1).split("][");
    var i = 0;
    var l = propertyArray.length;
    var property;
    var quot = "\"";
    while (i < l) {
        property = propertyArray[i];
        if (
            property.length > 2
            && property.charAt(0) === quot
            && property.slice(-1) === quot
        ) {
            property = property.slice(1, -1);
        }
        // bracket記法なら空文字列は妥当なkeyのはずなのでcommented out
        // if (property === "") {
        //     return undefined;
        // }
        if (typeof result[property] === "undefined") {
            return undefined;
        }
        result = result[property];
        i += 1;
    }
    return result;
};

(function () {
    "use strict";
    var maxlevel = 3104;
    var rxCancel = new RegExp(new Array(100 + 1).join(" "), "g");
    var p1 = "{\"type\":\"div\",\"attr\":{\"depth\":";
    var p2 = "},\"children\":[";
    var p3 = "]}";
    var c = "[\"children\"][0]";
    var json;
    var result = [];
    var q = [];
    var query;
    var i = 0;
    var l = maxlevel / 2;
    while (i < l) {
        result.push(p1 + (1 + i * 2) + p2);
        q.push(c);
        i += 1;
    }
    q.pop();
    while (i) {
        result.push(p3);
        i -= 1;
    }
    json = JSON.parse(result.join(""));
    query = q.join("") + "[\"attr\"][\"depth\"]";
    document.getElementById("TEST").appendChild(
        document.createTextNode(
            String("")
            // + JSON.stringify(json, null, 1).replace(rxCancel, "")
            + "\n\njson" + query + ": \n"
            + JSON.stringify(getProperty(json, query), null, 1)
        )
    );
}());
</script>

#TITLE else first
#BPM 130
#RANDOM 3
#ELSE
#00313:33
#IF 1
#00111:11
#ELSEIF 2
#00212:22
#ENDIF
#ENDRANDOM
#00115:55

入れ子あり・かつ終端符を補う拙作parserだとこうなるのもわかるけど、とはいえこれを見ていると「突然の#ELSE」を無条件で丸吞みするのはヤバなのでは……って思えてくる。“BABA IS YOU”だと突然のELSEは「該当条件なし」を意味するのだったか。私もそうすべきかな。nanasigroove1の場合、#ELSEは必ず選ばれ、あとは二択になる。Codeの動きがわからない。まあ「突然の#DEF」ならともかく、「突然の#ELSE」がどう解釈されても図表著者はどうこういえない。

[追記] Codeの動きがたぶん分かった。nanasigroove1は#ELSEIFをsupportしていないので、#ELSEIF 2はただの#ELSEとして解釈される、っぽい。

#TITLE void
#BPM 130
#SWITCH 1
#00111:11
#ENDSW

IIDXvはこういうのをきちんと叱ってくれるので良い。