@1771technologies/lytenyte-pro 2.0.0-dev.0 → 2.0.0-dev.1

package/dist/license/license.js

@@ -0,0 +1,215 @@
+const hashSalt = "faec0f3c45281b1fe12d87e64a6c3271";
+// @ts-expect-error will be replaced by build script
+const issueDate = globalThis.ISSUE_DATE ?? new Date("2023-03-01");
+function getHostname() {
+    const win = globalThis?.document?.defaultView || (typeof window !== "undefined" ? window : null);
+    const loc = win?.location;
+    const { hostname = "" } = loc ?? {};
+    return hostname;
+}
+function isWebsiteUrl() {
+    const hostname = getHostname();
+    return hostname.match(/^((?:\w+\.)?1771technologies\.com)$/) !== null;
+}
+function isLocalhost() {
+    const hostname = getHostname();
+    return hostname.match(/^(?:127\.0\.0\.1|localhost)$/) !== null;
+}
+export let hasAValidLicense = isWebsiteUrl() || isLocalhost();
+export let licenseState = null;
+export function activateLicense(license) {
+    const parts = license.split("|");
+    const details = parts[0];
+    const hash = parts[1];
+    const detailHash = new MD5().md5(details + hashSalt);
+    if (detailHash !== hash) {
+        console.error(`
+********************************************************************************
+  LyteNyte Grid PRO
+
+  Invalid license key. Please verify the key and try again.
+   
+  Visit https://1771technolgies.com for more information.
+********************************************************************************
+`);
+        licenseState = "invalid";
+        return false;
+    }
+    const detailParts = details.split(" ");
+    const endDate = new Date(detailParts[1]);
+    if (issueDate > endDate) {
+        console.error(`
+********************************************************************************
+  LyteNyte Grid PRO
+
+  License key expired. Your license covers earlier versions only.
+
+  Visit https://1771technolgies.com for more information.
+********************************************************************************
+`);
+        licenseState = "expired";
+        return false;
+    }
+    hasAValidLicense = true;
+    return true;
+}
+// see: https://www.myersdaily.org/joseph/javascript/md5-text.html
+// https://stackoverflow.com/a/1655795
+class MD5 {
+    md5cycle(x, k) {
+        let a = x[0];
+        let b = x[1];
+        let c = x[2];
+        let d = x[3];
+        a = this.ff(a, b, c, d, k[0], 7, -680876936);
+        d = this.ff(d, a, b, c, k[1], 12, -389564586);
+        c = this.ff(c, d, a, b, k[2], 17, 606105819);
+        b = this.ff(b, c, d, a, k[3], 22, -1044525330);
+        a = this.ff(a, b, c, d, k[4], 7, -176418897);
+        d = this.ff(d, a, b, c, k[5], 12, 1200080426);
+        c = this.ff(c, d, a, b, k[6], 17, -1473231341);
+        b = this.ff(b, c, d, a, k[7], 22, -45705983);
+        a = this.ff(a, b, c, d, k[8], 7, 1770035416);
+        d = this.ff(d, a, b, c, k[9], 12, -1958414417);
+        c = this.ff(c, d, a, b, k[10], 17, -42063);
+        b = this.ff(b, c, d, a, k[11], 22, -1990404162);
+        a = this.ff(a, b, c, d, k[12], 7, 1804603682);
+        d = this.ff(d, a, b, c, k[13], 12, -40341101);
+        c = this.ff(c, d, a, b, k[14], 17, -1502002290);
+        b = this.ff(b, c, d, a, k[15], 22, 1236535329);
+        a = this.gg(a, b, c, d, k[1], 5, -165796510);
+        d = this.gg(d, a, b, c, k[6], 9, -1069501632);
+        c = this.gg(c, d, a, b, k[11], 14, 643717713);
+        b = this.gg(b, c, d, a, k[0], 20, -373897302);
+        a = this.gg(a, b, c, d, k[5], 5, -701558691);
+        d = this.gg(d, a, b, c, k[10], 9, 38016083);
+        c = this.gg(c, d, a, b, k[15], 14, -660478335);
+        b = this.gg(b, c, d, a, k[4], 20, -405537848);
+        a = this.gg(a, b, c, d, k[9], 5, 568446438);
+        d = this.gg(d, a, b, c, k[14], 9, -1019803690);
+        c = this.gg(c, d, a, b, k[3], 14, -187363961);
+        b = this.gg(b, c, d, a, k[8], 20, 1163531501);
+        a = this.gg(a, b, c, d, k[13], 5, -1444681467);
+        d = this.gg(d, a, b, c, k[2], 9, -51403784);
+        c = this.gg(c, d, a, b, k[7], 14, 1735328473);
+        b = this.gg(b, c, d, a, k[12], 20, -1926607734);
+        a = this.hh(a, b, c, d, k[5], 4, -378558);
+        d = this.hh(d, a, b, c, k[8], 11, -2022574463);
+        c = this.hh(c, d, a, b, k[11], 16, 1839030562);
+        b = this.hh(b, c, d, a, k[14], 23, -35309556);
+        a = this.hh(a, b, c, d, k[1], 4, -1530992060);
+        d = this.hh(d, a, b, c, k[4], 11, 1272893353);
+        c = this.hh(c, d, a, b, k[7], 16, -155497632);
+        b = this.hh(b, c, d, a, k[10], 23, -1094730640);
+        a = this.hh(a, b, c, d, k[13], 4, 681279174);
+        d = this.hh(d, a, b, c, k[0], 11, -358537222);
+        c = this.hh(c, d, a, b, k[3], 16, -722521979);
+        b = this.hh(b, c, d, a, k[6], 23, 76029189);
+        a = this.hh(a, b, c, d, k[9], 4, -640364487);
+        d = this.hh(d, a, b, c, k[12], 11, -421815835);
+        c = this.hh(c, d, a, b, k[15], 16, 530742520);
+        b = this.hh(b, c, d, a, k[2], 23, -995338651);
+        a = this.ii(a, b, c, d, k[0], 6, -198630844);
+        d = this.ii(d, a, b, c, k[7], 10, 1126891415);
+        c = this.ii(c, d, a, b, k[14], 15, -1416354905);
+        b = this.ii(b, c, d, a, k[5], 21, -57434055);
+        a = this.ii(a, b, c, d, k[12], 6, 1700485571);
+        d = this.ii(d, a, b, c, k[3], 10, -1894986606);
+        c = this.ii(c, d, a, b, k[10], 15, -1051523);
+        b = this.ii(b, c, d, a, k[1], 21, -2054922799);
+        a = this.ii(a, b, c, d, k[8], 6, 1873313359);
+        d = this.ii(d, a, b, c, k[15], 10, -30611744);
+        c = this.ii(c, d, a, b, k[6], 15, -1560198380);
+        b = this.ii(b, c, d, a, k[13], 21, 1309151649);
+        a = this.ii(a, b, c, d, k[4], 6, -145523070);
+        d = this.ii(d, a, b, c, k[11], 10, -1120210379);
+        c = this.ii(c, d, a, b, k[2], 15, 718787259);
+        b = this.ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = this.add32(a, x[0]);
+        x[1] = this.add32(b, x[1]);
+        x[2] = this.add32(c, x[2]);
+        x[3] = this.add32(d, x[3]);
+    }
+    cmn(q, a, b, x, s, t) {
+        a = this.add32(this.add32(a, q), this.add32(x, t));
+        return this.add32((a << s) | (a >>> (32 - s)), b);
+    }
+    ff(a, b, c, d, x, s, t) {
+        return this.cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    gg(a, b, c, d, x, s, t) {
+        return this.cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    hh(a, b, c, d, x, s, t) {
+        return this.cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    ii(a, b, c, d, x, s, t) {
+        return this.cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    md51(s) {
+        const n = s.length;
+        const state = [1732584193, -271733879, -1732584194, 271733878];
+        let i;
+        for (i = 64; i <= s.length; i += 64) {
+            this.md5cycle(state, this.md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < s.length; i++) {
+            tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 0x80 << (i % 4 << 3);
+        if (i > 55) {
+            this.md5cycle(state, tail);
+            for (i = 0; i < 16; i++) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = n * 8;
+        this.md5cycle(state, tail);
+        return state;
+    }
+    /* there needs to be support for Unicode here, * unless we pretend that we can redefine the MD-5
+     * algorithm for multi-byte characters (perhaps by adding every four 16-bit characters and
+     * shortening the sum to 32 bits). Otherwise I suthis.ggest performing MD-5 as if every character
+     * was two bytes--e.g., 0040 0025 = @%--but then how will an ordinary MD-5 sum be matched?
+     * There is no way to standardize text to something like UTF-8 before transformation; speed cost is
+     * utterly prohibitive. The JavaScript standard itself needs to look at this: it should start
+     * providing access to strings as preformed UTF-8 8-bit unsigned value arrays.
+     */
+    md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    rhex(n) {
+        const hex_chr = "0123456789abcdef".split("");
+        let s = "";
+        let j = 0;
+        for (; j < 4; j++) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+        }
+        return s;
+    }
+    hex(x) {
+        for (let i = 0; i < x.length; i++) {
+            x[i] = this.rhex(x[i]);
+        }
+        return x.join("");
+    }
+    md5(s) {
+        return this.hex(this.md51(s));
+    }
+    add32(a, b) {
+        return this.add32Std(a, b);
+    }
+    add32Std(a, b) {
+        return (a + b) & 0xffffffff;
+    }
+}

package/dist/license/md5-hash.d.ts

@@ -0,0 +1,9 @@
+interface GetHashArguments {
+    companyName: string;
+    startDate: string;
+    endDate: string;
+    randomString: string;
+    licenseType: "seated" | "company-wide";
+}
+export declare function getHash({ companyName, startDate, endDate, licenseType, randomString }: GetHashArguments): string;
+export {};

package/dist/license/md5-hash.js

@@ -0,0 +1,167 @@
+// WARNING --- DO NOT TOUCH THIS STRING OR THIS MODULE.
+const hashSalt = "faec0f3c45281b1fe12d87e64a6c3271";
+export function getHash({ companyName, startDate, endDate, licenseType, randomString }) {
+    const details = `${startDate} ${endDate} ${companyName} ${licenseType} ${randomString}`;
+    const hash = new MD5().md5(details + hashSalt);
+    return `${details}|${hash}`;
+}
+// see: https://www.myersdaily.org/joseph/javascript/md5-text.html
+// https://stackoverflow.com/a/1655795
+class MD5 {
+    md5cycle(x, k) {
+        let a = x[0];
+        let b = x[1];
+        let c = x[2];
+        let d = x[3];
+        a = this.ff(a, b, c, d, k[0], 7, -680876936);
+        d = this.ff(d, a, b, c, k[1], 12, -389564586);
+        c = this.ff(c, d, a, b, k[2], 17, 606105819);
+        b = this.ff(b, c, d, a, k[3], 22, -1044525330);
+        a = this.ff(a, b, c, d, k[4], 7, -176418897);
+        d = this.ff(d, a, b, c, k[5], 12, 1200080426);
+        c = this.ff(c, d, a, b, k[6], 17, -1473231341);
+        b = this.ff(b, c, d, a, k[7], 22, -45705983);
+        a = this.ff(a, b, c, d, k[8], 7, 1770035416);
+        d = this.ff(d, a, b, c, k[9], 12, -1958414417);
+        c = this.ff(c, d, a, b, k[10], 17, -42063);
+        b = this.ff(b, c, d, a, k[11], 22, -1990404162);
+        a = this.ff(a, b, c, d, k[12], 7, 1804603682);
+        d = this.ff(d, a, b, c, k[13], 12, -40341101);
+        c = this.ff(c, d, a, b, k[14], 17, -1502002290);
+        b = this.ff(b, c, d, a, k[15], 22, 1236535329);
+        a = this.gg(a, b, c, d, k[1], 5, -165796510);
+        d = this.gg(d, a, b, c, k[6], 9, -1069501632);
+        c = this.gg(c, d, a, b, k[11], 14, 643717713);
+        b = this.gg(b, c, d, a, k[0], 20, -373897302);
+        a = this.gg(a, b, c, d, k[5], 5, -701558691);
+        d = this.gg(d, a, b, c, k[10], 9, 38016083);
+        c = this.gg(c, d, a, b, k[15], 14, -660478335);
+        b = this.gg(b, c, d, a, k[4], 20, -405537848);
+        a = this.gg(a, b, c, d, k[9], 5, 568446438);
+        d = this.gg(d, a, b, c, k[14], 9, -1019803690);
+        c = this.gg(c, d, a, b, k[3], 14, -187363961);
+        b = this.gg(b, c, d, a, k[8], 20, 1163531501);
+        a = this.gg(a, b, c, d, k[13], 5, -1444681467);
+        d = this.gg(d, a, b, c, k[2], 9, -51403784);
+        c = this.gg(c, d, a, b, k[7], 14, 1735328473);
+        b = this.gg(b, c, d, a, k[12], 20, -1926607734);
+        a = this.hh(a, b, c, d, k[5], 4, -378558);
+        d = this.hh(d, a, b, c, k[8], 11, -2022574463);
+        c = this.hh(c, d, a, b, k[11], 16, 1839030562);
+        b = this.hh(b, c, d, a, k[14], 23, -35309556);
+        a = this.hh(a, b, c, d, k[1], 4, -1530992060);
+        d = this.hh(d, a, b, c, k[4], 11, 1272893353);
+        c = this.hh(c, d, a, b, k[7], 16, -155497632);
+        b = this.hh(b, c, d, a, k[10], 23, -1094730640);
+        a = this.hh(a, b, c, d, k[13], 4, 681279174);
+        d = this.hh(d, a, b, c, k[0], 11, -358537222);
+        c = this.hh(c, d, a, b, k[3], 16, -722521979);
+        b = this.hh(b, c, d, a, k[6], 23, 76029189);
+        a = this.hh(a, b, c, d, k[9], 4, -640364487);
+        d = this.hh(d, a, b, c, k[12], 11, -421815835);
+        c = this.hh(c, d, a, b, k[15], 16, 530742520);
+        b = this.hh(b, c, d, a, k[2], 23, -995338651);
+        a = this.ii(a, b, c, d, k[0], 6, -198630844);
+        d = this.ii(d, a, b, c, k[7], 10, 1126891415);
+        c = this.ii(c, d, a, b, k[14], 15, -1416354905);
+        b = this.ii(b, c, d, a, k[5], 21, -57434055);
+        a = this.ii(a, b, c, d, k[12], 6, 1700485571);
+        d = this.ii(d, a, b, c, k[3], 10, -1894986606);
+        c = this.ii(c, d, a, b, k[10], 15, -1051523);
+        b = this.ii(b, c, d, a, k[1], 21, -2054922799);
+        a = this.ii(a, b, c, d, k[8], 6, 1873313359);
+        d = this.ii(d, a, b, c, k[15], 10, -30611744);
+        c = this.ii(c, d, a, b, k[6], 15, -1560198380);
+        b = this.ii(b, c, d, a, k[13], 21, 1309151649);
+        a = this.ii(a, b, c, d, k[4], 6, -145523070);
+        d = this.ii(d, a, b, c, k[11], 10, -1120210379);
+        c = this.ii(c, d, a, b, k[2], 15, 718787259);
+        b = this.ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = this.add32(a, x[0]);
+        x[1] = this.add32(b, x[1]);
+        x[2] = this.add32(c, x[2]);
+        x[3] = this.add32(d, x[3]);
+    }
+    cmn(q, a, b, x, s, t) {
+        a = this.add32(this.add32(a, q), this.add32(x, t));
+        return this.add32((a << s) | (a >>> (32 - s)), b);
+    }
+    ff(a, b, c, d, x, s, t) {
+        return this.cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    gg(a, b, c, d, x, s, t) {
+        return this.cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    hh(a, b, c, d, x, s, t) {
+        return this.cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    ii(a, b, c, d, x, s, t) {
+        return this.cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    md51(s) {
+        const n = s.length;
+        const state = [1732584193, -271733879, -1732584194, 271733878];
+        let i;
+        for (i = 64; i <= s.length; i += 64) {
+            this.md5cycle(state, this.md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < s.length; i++) {
+            tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 0x80 << (i % 4 << 3);
+        if (i > 55) {
+            this.md5cycle(state, tail);
+            for (i = 0; i < 16; i++) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = n * 8;
+        this.md5cycle(state, tail);
+        return state;
+    }
+    /* there needs to be support for Unicode here, * unless we pretend that we can redefine the MD-5
+     * algorithm for multi-byte characters (perhaps by adding every four 16-bit characters and
+     * shortening the sum to 32 bits). Otherwise I suthis.ggest performing MD-5 as if every character
+     * was two bytes--e.g., 0040 0025 = @%--but then how will an ordinary MD-5 sum be matched?
+     * There is no way to standardize text to something like UTF-8 before transformation; speed cost is
+     * utterly prohibitive. The JavaScript standard itself needs to look at this: it should start
+     * providing access to strings as preformed UTF-8 8-bit unsigned value arrays.
+     */
+    md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    rhex(n) {
+        const hex_chr = "0123456789abcdef".split("");
+        let s = "";
+        let j = 0;
+        for (; j < 4; j++) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+        }
+        return s;
+    }
+    hex(x) {
+        for (let i = 0; i < x.length; i++) {
+            x[i] = this.rhex(x[i]);
+        }
+        return x.join("");
+    }
+    md5(s) {
+        return this.hex(this.md51(s));
+    }
+    add32(a, b) {
+        return this.add32Std(a, b);
+    }
+    add32Std(a, b) {
+        return (a + b) & 0xffffffff;
+    }
+}

package/dist/license.d.ts

@@ -0,0 +1,3 @@
+export function activateLicense(license: any): boolean;
+export let hasAValidLicense: boolean;
+export let licenseState: null;

package/dist/license.js

@@ -0,0 +1,214 @@
+const hashSalt = "faec0f3c45281b1fe12d87e64a6c3271";
+const issueDate = new Date("2025-10-05");
+function getHostname() {
+    const win = globalThis?.document?.defaultView || (typeof window !== "undefined" ? window : null);
+    const loc = win?.location;
+    const { hostname = "" } = loc ?? {};
+    return hostname;
+}
+function isWebsiteUrl() {
+    const hostname = getHostname();
+    return hostname.match(/^((?:\w+\.)?1771technologies\.com)$/) !== null;
+}
+function isLocalhost() {
+    const hostname = getHostname();
+    return hostname.match(/^(?:127\.0\.0\.1|localhost)$/) !== null;
+}
+export let hasAValidLicense = isWebsiteUrl() || isLocalhost();
+export let licenseState = null;
+export function activateLicense(license) {
+    const parts = license.split("|");
+    const details = parts[0];
+    const hash = parts[1];
+    const detailHash = new MD5().md5(details + hashSalt);
+    if (detailHash !== hash) {
+        console.error(`
+********************************************************************************
+  LyteNyte Grid PRO
+
+  Invalid license key. Please verify the key and try again.
+
+  Visit https://1771technolgies.com for more information.
+********************************************************************************
+`);
+        licenseState = "invalid";
+        return false;
+    }
+    const detailParts = details.split(" ");
+    const endDate = new Date(detailParts[1]);
+    if (issueDate > endDate) {
+        console.error(`
+********************************************************************************
+  LyteNyte Grid PRO
+
+  License key expired. Your license covers earlier versions only.
+
+  Visit https://1771technolgies.com for more information.
+********************************************************************************
+`);
+        licenseState = "expired";
+        return false;
+    }
+    hasAValidLicense = true;
+    return true;
+}
+// see: https://www.myersdaily.org/joseph/javascript/md5-text.html
+// https://stackoverflow.com/a/1655795
+class MD5 {
+    md5cycle(x, k) {
+        let a = x[0];
+        let b = x[1];
+        let c = x[2];
+        let d = x[3];
+        a = this.ff(a, b, c, d, k[0], 7, -680876936);
+        d = this.ff(d, a, b, c, k[1], 12, -389564586);
+        c = this.ff(c, d, a, b, k[2], 17, 606105819);
+        b = this.ff(b, c, d, a, k[3], 22, -1044525330);
+        a = this.ff(a, b, c, d, k[4], 7, -176418897);
+        d = this.ff(d, a, b, c, k[5], 12, 1200080426);
+        c = this.ff(c, d, a, b, k[6], 17, -1473231341);
+        b = this.ff(b, c, d, a, k[7], 22, -45705983);
+        a = this.ff(a, b, c, d, k[8], 7, 1770035416);
+        d = this.ff(d, a, b, c, k[9], 12, -1958414417);
+        c = this.ff(c, d, a, b, k[10], 17, -42063);
+        b = this.ff(b, c, d, a, k[11], 22, -1990404162);
+        a = this.ff(a, b, c, d, k[12], 7, 1804603682);
+        d = this.ff(d, a, b, c, k[13], 12, -40341101);
+        c = this.ff(c, d, a, b, k[14], 17, -1502002290);
+        b = this.ff(b, c, d, a, k[15], 22, 1236535329);
+        a = this.gg(a, b, c, d, k[1], 5, -165796510);
+        d = this.gg(d, a, b, c, k[6], 9, -1069501632);
+        c = this.gg(c, d, a, b, k[11], 14, 643717713);
+        b = this.gg(b, c, d, a, k[0], 20, -373897302);
+        a = this.gg(a, b, c, d, k[5], 5, -701558691);
+        d = this.gg(d, a, b, c, k[10], 9, 38016083);
+        c = this.gg(c, d, a, b, k[15], 14, -660478335);
+        b = this.gg(b, c, d, a, k[4], 20, -405537848);
+        a = this.gg(a, b, c, d, k[9], 5, 568446438);
+        d = this.gg(d, a, b, c, k[14], 9, -1019803690);
+        c = this.gg(c, d, a, b, k[3], 14, -187363961);
+        b = this.gg(b, c, d, a, k[8], 20, 1163531501);
+        a = this.gg(a, b, c, d, k[13], 5, -1444681467);
+        d = this.gg(d, a, b, c, k[2], 9, -51403784);
+        c = this.gg(c, d, a, b, k[7], 14, 1735328473);
+        b = this.gg(b, c, d, a, k[12], 20, -1926607734);
+        a = this.hh(a, b, c, d, k[5], 4, -378558);
+        d = this.hh(d, a, b, c, k[8], 11, -2022574463);
+        c = this.hh(c, d, a, b, k[11], 16, 1839030562);
+        b = this.hh(b, c, d, a, k[14], 23, -35309556);
+        a = this.hh(a, b, c, d, k[1], 4, -1530992060);
+        d = this.hh(d, a, b, c, k[4], 11, 1272893353);
+        c = this.hh(c, d, a, b, k[7], 16, -155497632);
+        b = this.hh(b, c, d, a, k[10], 23, -1094730640);
+        a = this.hh(a, b, c, d, k[13], 4, 681279174);
+        d = this.hh(d, a, b, c, k[0], 11, -358537222);
+        c = this.hh(c, d, a, b, k[3], 16, -722521979);
+        b = this.hh(b, c, d, a, k[6], 23, 76029189);
+        a = this.hh(a, b, c, d, k[9], 4, -640364487);
+        d = this.hh(d, a, b, c, k[12], 11, -421815835);
+        c = this.hh(c, d, a, b, k[15], 16, 530742520);
+        b = this.hh(b, c, d, a, k[2], 23, -995338651);
+        a = this.ii(a, b, c, d, k[0], 6, -198630844);
+        d = this.ii(d, a, b, c, k[7], 10, 1126891415);
+        c = this.ii(c, d, a, b, k[14], 15, -1416354905);
+        b = this.ii(b, c, d, a, k[5], 21, -57434055);
+        a = this.ii(a, b, c, d, k[12], 6, 1700485571);
+        d = this.ii(d, a, b, c, k[3], 10, -1894986606);
+        c = this.ii(c, d, a, b, k[10], 15, -1051523);
+        b = this.ii(b, c, d, a, k[1], 21, -2054922799);
+        a = this.ii(a, b, c, d, k[8], 6, 1873313359);
+        d = this.ii(d, a, b, c, k[15], 10, -30611744);
+        c = this.ii(c, d, a, b, k[6], 15, -1560198380);
+        b = this.ii(b, c, d, a, k[13], 21, 1309151649);
+        a = this.ii(a, b, c, d, k[4], 6, -145523070);
+        d = this.ii(d, a, b, c, k[11], 10, -1120210379);
+        c = this.ii(c, d, a, b, k[2], 15, 718787259);
+        b = this.ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = this.add32(a, x[0]);
+        x[1] = this.add32(b, x[1]);
+        x[2] = this.add32(c, x[2]);
+        x[3] = this.add32(d, x[3]);
+    }
+    cmn(q, a, b, x, s, t) {
+        a = this.add32(this.add32(a, q), this.add32(x, t));
+        return this.add32((a << s) | (a >>> (32 - s)), b);
+    }
+    ff(a, b, c, d, x, s, t) {
+        return this.cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    gg(a, b, c, d, x, s, t) {
+        return this.cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    hh(a, b, c, d, x, s, t) {
+        return this.cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    ii(a, b, c, d, x, s, t) {
+        return this.cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    md51(s) {
+        const n = s.length;
+        const state = [1732584193, -271733879, -1732584194, 271733878];
+        let i;
+        for (i = 64; i <= s.length; i += 64) {
+            this.md5cycle(state, this.md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < s.length; i++) {
+            tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 0x80 << (i % 4 << 3);
+        if (i > 55) {
+            this.md5cycle(state, tail);
+            for (i = 0; i < 16; i++) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = n * 8;
+        this.md5cycle(state, tail);
+        return state;
+    }
+    /* there needs to be support for Unicode here, * unless we pretend that we can redefine the MD-5
+     * algorithm for multi-byte characters (perhaps by adding every four 16-bit characters and
+     * shortening the sum to 32 bits). Otherwise I suthis.ggest performing MD-5 as if every character
+     * was two bytes--e.g., 0040 0025 = @%--but then how will an ordinary MD-5 sum be matched?
+     * There is no way to standardize text to something like UTF-8 before transformation; speed cost is
+     * utterly prohibitive. The JavaScript standard itself needs to look at this: it should start
+     * providing access to strings as preformed UTF-8 8-bit unsigned value arrays.
+     */
+    md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    rhex(n) {
+        const hex_chr = "0123456789abcdef".split("");
+        let s = "";
+        let j = 0;
+        for (; j < 4; j++) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+        }
+        return s;
+    }
+    hex(x) {
+        for (let i = 0; i < x.length; i++) {
+            x[i] = this.rhex(x[i]);
+        }
+        return x.join("");
+    }
+    md5(s) {
+        return this.hex(this.md51(s));
+    }
+    add32(a, b) {
+        return this.add32Std(a, b);
+    }
+    add32Std(a, b) {
+        return (a + b) & 0xffffffff;
+    }
+}

package/dist/root/context.d.ts

@@ -0,0 +1,16 @@
+import { type Dispatch, type RefObject, type SetStateAction } from "react";
+import type { API, DataRect, DataRectSplit } from "../types";
+export interface ProContext {
+    readonly api: API;
+    readonly excludeMarker: boolean;
+    readonly keepSelection: boolean;
+    readonly cellSelections: DataRect[];
+    readonly onCellSelectionChange: (rect: DataRect[]) => void;
+    readonly cellSelectionMode: "range" | "multi-range" | "none";
+    readonly cellSelectionAdditiveRects: DataRectSplit[] | null;
+    readonly setCellSelectionAdditiveRects: Dispatch<SetStateAction<DataRectSplit[] | null>>;
+    readonly cellSelectionIsDeselect: RefObject<boolean>;
+    readonly cellSelectionSplits: DataRectSplit[];
+}
+export declare const ProRootProvider: import("react").Provider<ProContext>;
+export declare const useProRoot: () => ProContext;

package/dist/root/context.js

@@ -0,0 +1,4 @@
+import { createContext, useContext } from "react";
+const context = createContext({});
+export const ProRootProvider = context.Provider;
+export const useProRoot = () => useContext(context);

package/dist/root/hooks/use-pro-api.d.ts

@@ -0,0 +1,2 @@
+import type { API, DataRect } from "../../types";
+export declare function useProAPI(cellSelections: DataRect[]): API;

package/dist/root/hooks/use-pro-api.js

@@ -0,0 +1,8 @@
+import { useEvent, useRoot } from "@1771technologies/lytenyte-core/internal";
+import {} from "@1771technologies/lytenyte-shared";
+export function useProAPI(cellSelections) {
+    const { api: coreApi } = useRoot();
+    const api = coreApi;
+    api.cellSelections = useEvent(() => cellSelections);
+    return api;
+}

package/dist/root/root.d.ts

@@ -0,0 +1,15 @@
+import { type PropsWithChildren, type ReactNode } from "react";
+import type { GridSpec as LnSpec } from "../types/grid.js";
+import type { Column as LnColumn } from "../types/column.js";
+import type { API as LnAPI } from "../types/api.js";
+import type { Props as LnProps } from "../types/props.js";
+import type { RowSource } from "@1771technologies/lytenyte-shared";
+export declare const Root: <Spec extends Root.GridSpec = Root.GridSpec>(props: PropsWithChildren<Root.Props<Spec> & (undefined extends Spec["api"] ? object : {
+    apiExtension: Spec["api"];
+})>) => ReactNode;
+export declare namespace Root {
+    type GridSpec<T = unknown, C extends Record<string, any> = object, S extends RowSource<T> = RowSource, E extends Record<string, any> = object> = LnSpec<T, C, S, E>;
+    type Props<Spec extends GridSpec = GridSpec> = LnProps<Spec>;
+    type API<Spec extends GridSpec = GridSpec> = LnAPI<Spec>;
+    type Column<Spec extends GridSpec = GridSpec> = LnColumn<Spec>;
+}