@wodzik/cubecore 0.1.0

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/protocols/qiyi.js

@@ -0,0 +1,424 @@
+import { Subject } from 'rxjs';
+import { ModeOfOperation } from 'aes-js';
+import { normalizeUuid } from '../attachment/normalize-uuid.js';
+import { getCachedMacForDevice } from '../attachment/address-hints.js';
+import { buildQiYiMacCandidatesFromName } from '../attachment/mac-candidates.js';
+import { probeQiYiMac } from '../attachment/mac-probe-qiyi.js';
+import { registerProtocol } from '../protocol.js';
+import { CubieCube } from '../cubie-cube.js';
+import { now, findCharacteristic, waitForAdvertisements, extractMacFromManufacturerData } from '../ble-utils.js';
+import { writeGattCharacteristicValue } from '../../gatt-characteristic-write.js';
+const UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+const SERVICE_UUID = '0000fff0' + UUID_SUFFIX;
+const CHRCT_UUID_CUBE = '0000fff6' + UUID_SUFFIX;
+const QIYI_CIC_LIST = [0x0504];
+const QIYI_KEY = [87, 177, 249, 171, 205, 90, 232, 167, 156, 185, 140, 231, 87, 140, 81, 8];
+/** Kociemba facelet string for solved cube */
+const QIYI_SOLVED_FACELETS = 'UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB';
+function crc16modbus(data) {
+    let crc = 0xFFFF;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc & 0x1) > 0 ? (crc >> 1) ^ 0xa001 : crc >> 1;
+        }
+    }
+    return crc;
+}
+class QiYiEncrypter {
+    cipher;
+    constructor() {
+        this.cipher = new ModeOfOperation.ecb(new Uint8Array(QIYI_KEY));
+    }
+    encrypt(data) {
+        const result = [];
+        for (let i = 0; i < data.length; i += 16) {
+            const block = data.slice(i, i + 16);
+            const encrypted = this.cipher.encrypt(new Uint8Array(block));
+            for (let j = 0; j < 16; j++) {
+                result[i + j] = encrypted[j];
+            }
+        }
+        return result;
+    }
+    decrypt(data) {
+        const result = [];
+        for (let i = 0; i < data.length; i += 16) {
+            const block = data.slice(i, i + 16);
+            const decrypted = this.cipher.decrypt(new Uint8Array(block));
+            for (let j = 0; j < 16; j++) {
+                result[i + j] = decrypted[j];
+            }
+        }
+        return result;
+    }
+}
+function parseFacelet(faceMsg) {
+    const ret = [];
+    for (let i = 0; i < 54; i++) {
+        ret.push("LRDUFB".charAt((faceMsg[i >> 1] >> ((i % 2) << 2)) & 0xf));
+    }
+    return ret.join("");
+}
+/** Device timestamps in bytes 3–6 and history slots: big-endian uint32 */
+function readQiYiTimestampBE(msg, offset) {
+    return (msg[offset] << 24) | (msg[offset + 1] << 16) | (msg[offset + 2] << 8) | msg[offset + 3];
+}
+/** Collect primary + all 11 history slots (bytes 36..90) */
+function collectQiYiStateChangeMoves(msg, headerTs) {
+    const out = [[msg[34], headerTs]];
+    for (let i = 0; i < 11; i++) {
+        const off = 36 + 5 * i;
+        if (off + 5 > msg.length)
+            break;
+        let allFf = true;
+        for (let j = 0; j < 5; j++) {
+            if (msg[off + j] !== 0xff) {
+                allFf = false;
+                break;
+            }
+        }
+        if (allFf)
+            continue;
+        const slotTs = readQiYiTimestampBE(msg, off);
+        const code = msg[off + 4];
+        out.push([code, slotTs]);
+    }
+    out.sort((a, b) => a[1] - b[1]);
+    const seen = new Set();
+    return out.filter(([code, t]) => {
+        const k = `${code},${t}`;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+const QIYI_PROTOCOL = { id: 'qiyi', name: 'QiYi' };
+class QiYiConnection {
+    deviceName;
+    deviceMAC;
+    protocol = QIYI_PROTOCOL;
+    capabilities = {
+        gyroscope: false,
+        battery: true,
+        facelets: true,
+        hardware: true,
+        reset: false
+    };
+    events$;
+    device;
+    cubeChrct = null;
+    encrypter;
+    curCubie = new CubieCube();
+    prevCubie = new CubieCube();
+    lastTs = 0;
+    lastBatteryLevel = null;
+    forceNextBatteryEmission = false;
+    writeChain = Promise.resolve();
+    constructor(device, mac) {
+        this.device = device;
+        this.deviceName = device.name || 'QiYi';
+        this.deviceMAC = mac;
+        this.events$ = new Subject();
+        this.encrypter = new QiYiEncrypter();
+    }
+    sendMessage(content) {
+        if (!this.cubeChrct)
+            return Promise.reject();
+        const ch = this.cubeChrct;
+        const run = async () => {
+            const msg = [0xfe];
+            msg.push(4 + content.length);
+            for (let i = 0; i < content.length; i++) {
+                msg.push(content[i]);
+            }
+            const crc = crc16modbus(msg);
+            msg.push(crc & 0xff, crc >> 8);
+            const npad = (16 - msg.length % 16) % 16;
+            for (let i = 0; i < npad; i++) {
+                msg.push(0);
+            }
+            const encMsg = this.encrypter.encrypt(msg);
+            await writeGattCharacteristicValue(ch, new Uint8Array(encMsg).buffer);
+        };
+        this.writeChain = this.writeChain.then(run, run);
+        return this.writeChain;
+    }
+    sendHello() {
+        const macBytes = this.deviceMAC.split(/[:-\s]+/).map(c => parseInt(c, 16));
+        const content = [0x00, 0x6b, 0x01, 0x00, 0x00, 0x22, 0x06, 0x00, 0x02, 0x08, 0x00];
+        for (let i = 5; i >= 0; i--) {
+            content.push(macBytes[i] || 0);
+        }
+        return this.sendMessage(content);
+    }
+    onCubeEvent = (event) => {
+        const value = event.target.value;
+        if (!value)
+            return;
+        const encMsg = [];
+        for (let i = 0; i < value.byteLength; i++) {
+            encMsg[i] = value.getUint8(i);
+        }
+        const msg = this.encrypter.decrypt(encMsg);
+        if (msg[0] === 0xCC && msg[1] === 0x10) {
+            this.handleQuaternionPacket(msg);
+            return;
+        }
+        const trimmed = msg.slice(0, msg[1]);
+        if (trimmed.length < 3 || crc16modbus(trimmed) !== 0) {
+            return;
+        }
+        this.parseCubeData(trimmed);
+    };
+    handleQuaternionPacket(msg) {
+        if (msg.length < 16)
+            return;
+        const expectedCrc = crc16modbus(msg.slice(0, 14));
+        const actualCrc = msg[14] | (msg[15] << 8);
+        if (expectedCrc !== actualCrc)
+            return;
+        if (!this.capabilities.gyroscope) {
+            this.capabilities.gyroscope = true;
+        }
+        const dv = new DataView(Uint8Array.from(msg).buffer);
+        const ax = dv.getInt16(6, false) / 1000;
+        const ay = dv.getInt16(8, false) / 1000;
+        const az = dv.getInt16(10, false) / 1000;
+        const aw = dv.getInt16(12, false) / 1000;
+        this.events$.next({
+            timestamp: now(),
+            type: "GYRO",
+            quaternion: {
+                x: ax,
+                y: -az,
+                z: ay,
+                w: aw
+            }
+        });
+    }
+    emitHardwareEvent() {
+        this.events$.next({
+            timestamp: now(),
+            type: "HARDWARE",
+            hardwareName: this.deviceName,
+            gyroSupported: this.capabilities.gyroscope
+        });
+    }
+    emitBatteryLevel(rawLevel, timestamp = now()) {
+        if (!Number.isFinite(rawLevel)) {
+            return;
+        }
+        const batteryLevel = Math.min(100, Math.max(0, Math.round(rawLevel)));
+        const forceEmission = this.forceNextBatteryEmission;
+        this.forceNextBatteryEmission = false;
+        if (!forceEmission && this.lastBatteryLevel === batteryLevel) {
+            return;
+        }
+        this.lastBatteryLevel = batteryLevel;
+        this.events$.next({
+            timestamp,
+            type: 'BATTERY',
+            batteryLevel,
+        });
+    }
+    parseCubeData(msg) {
+        const timestamp = now();
+        if (msg[0] !== 0xfe)
+            return;
+        const opcode = msg[2];
+        const ts = readQiYiTimestampBE(msg, 3);
+        if (opcode === 0x2) {
+            // Hello response — always ACK
+            this.sendMessage(msg.slice(2, 7)).catch(() => { });
+            const newFacelet = parseFacelet(msg.slice(7, 34));
+            this.events$.next({
+                timestamp,
+                type: "FACELETS",
+                facelets: newFacelet
+            });
+            this.emitBatteryLevel(msg[35], timestamp);
+            this.prevCubie.fromFacelet(newFacelet);
+            this.lastTs = ts;
+            return;
+        }
+        if (opcode === 0x3) {
+            const needsAck = msg.length > 91 && msg[91] !== 0;
+            if (needsAck) {
+                this.sendMessage(msg.slice(2, 7)).catch(() => { });
+            }
+            const candidates = collectQiYiStateChangeMoves(msg, ts);
+            const newMoves = candidates.filter(([code, moveTs]) => code >= 1 && code <= 12 && moveTs > this.lastTs);
+            for (let k = 0; k < newMoves.length; k++) {
+                const [code, moveTs] = newMoves[k];
+                const axis = [4, 1, 3, 0, 2, 5][(code - 1) >> 1];
+                const power = [0, 2][code & 1];
+                const m = axis * 3 + power;
+                const moveStr = ("URFDLB".charAt(axis) + " 2'".charAt(power)).trim();
+                CubieCube.CubeMult(this.prevCubie, CubieCube.moveCube[m], this.curCubie);
+                const facelet = this.curCubie.toFaceCube();
+                this.events$.next({
+                    timestamp,
+                    type: "MOVE",
+                    face: axis,
+                    direction: power === 0 ? 0 : 1,
+                    move: moveStr,
+                    localTimestamp: k === newMoves.length - 1 ? timestamp : null,
+                    cubeTimestamp: Math.trunc(moveTs / 1.6)
+                });
+                this.events$.next({
+                    timestamp,
+                    type: "FACELETS",
+                    facelets: facelet
+                });
+                const tmp = this.curCubie;
+                this.curCubie = this.prevCubie;
+                this.prevCubie = tmp;
+            }
+            if (newMoves.length > 0) {
+                this.lastTs = newMoves[newMoves.length - 1][1];
+            }
+            this.emitBatteryLevel(msg[35], timestamp);
+            return;
+        }
+        if (opcode === 0x4) {
+            // Sync confirmation: emit solved state; no ACK for op 4 in reference protocol.
+            if (msg[1] !== 38)
+                return;
+            this.events$.next({
+                timestamp,
+                type: "FACELETS",
+                facelets: QIYI_SOLVED_FACELETS
+            });
+            this.prevCubie.fromFacelet(QIYI_SOLVED_FACELETS);
+            this.lastTs = ts;
+            return;
+        }
+        // Unknown opcode: do not advance lastTs (avoids skewing move history filters).
+    }
+    onDisconnect = () => {
+        this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+        this.lastBatteryLevel = null;
+        this.forceNextBatteryEmission = false;
+        this.events$.next({ timestamp: now(), type: "DISCONNECT" });
+        this.events$.complete();
+    };
+    async init() {
+        this.device.addEventListener('gattserverdisconnected', this.onDisconnect);
+        const gatt = await this.device.gatt.connect();
+        const service = await gatt.getPrimaryService(SERVICE_UUID);
+        const chrcts = await service.getCharacteristics();
+        this.cubeChrct = findCharacteristic(chrcts, CHRCT_UUID_CUBE);
+        if (!this.cubeChrct) {
+            throw new Error('[QiYi] Cannot find required characteristic');
+        }
+        this.cubeChrct.addEventListener('characteristicvaluechanged', this.onCubeEvent);
+        await this.cubeChrct.startNotifications();
+        await this.sendHello();
+    }
+    async sendCommand(command) {
+        if (command.type === "REQUEST_FACELETS" || command.type === "REQUEST_BATTERY") {
+            if (command.type === "REQUEST_BATTERY") {
+                this.forceNextBatteryEmission = true;
+            }
+            await this.sendHello();
+        }
+        else if (command.type === "REQUEST_HARDWARE") {
+            this.emitHardwareEvent();
+        }
+    }
+    async disconnect() {
+        if (this.cubeChrct) {
+            this.cubeChrct.removeEventListener('characteristicvaluechanged', this.onCubeEvent);
+            await this.cubeChrct.stopNotifications().catch(() => { });
+            this.cubeChrct = null;
+        }
+        this.lastBatteryLevel = null;
+        this.forceNextBatteryEmission = false;
+        this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+        this.events$.next({ timestamp: now(), type: "DISCONNECT" });
+        this.events$.complete();
+        if (this.device.gatt?.connected) {
+            this.device.gatt.disconnect();
+        }
+    }
+}
+function parseQiYiMacFromMf(mfData) {
+    if (!mfData) {
+        return null;
+    }
+    return extractMacFromManufacturerData(mfData, QIYI_CIC_LIST, true);
+}
+async function connectQiYiDevice(device, macProvider, context) {
+    let mac = parseQiYiMacFromMf(context?.advertisementManufacturerData ?? null);
+    mac = mac || getCachedMacForDevice(device);
+    if (!mac && macProvider) {
+        const r = await macProvider(device, false);
+        if (r) {
+            mac = r;
+        }
+    }
+    if (!mac) {
+        const mfData = await waitForAdvertisements(device, context?.enableAddressSearch ? 8000 : 5000);
+        mac = parseQiYiMacFromMf(mfData);
+    }
+    if (!mac) {
+        const c = buildQiYiMacCandidatesFromName(device.name);
+        if (c.length === 1) {
+            mac = c[0];
+        }
+    }
+    if (!mac && context?.enableAddressSearch) {
+        const candidates = buildQiYiMacCandidatesFromName(device.name);
+        const timeoutMs = 3000;
+        for (let i = 0; i < candidates.length; i++) {
+            if (context.signal?.aborted) {
+                break;
+            }
+            context.onStatus?.(`Testing address (${i + 1}/${candidates.length})…`);
+            try {
+                if (await probeQiYiMac(device, candidates[i], {
+                    timeoutMs,
+                    signal: context.signal,
+                })) {
+                    mac = candidates[i];
+                    break;
+                }
+            }
+            catch {
+                /* try next */
+            }
+        }
+    }
+    if (!mac && macProvider) {
+        const r = await macProvider(device, true);
+        if (r) {
+            mac = r;
+        }
+    }
+    if (!mac) {
+        throw new Error('Unable to determine QiYi cube MAC address');
+    }
+    const conn = new QiYiConnection(device, mac);
+    await conn.init();
+    return conn;
+}
+const qiyiProtocol = {
+    nameFilters: [
+        { namePrefix: "QY-QYSC" },
+        { namePrefix: "XMD-TornadoV4-i" }
+    ],
+    optionalServices: [SERVICE_UUID],
+    optionalManufacturerData: QIYI_CIC_LIST,
+    matchesDevice(device) {
+        const name = device.name || '';
+        return name.startsWith('QY-QYSC') || name.startsWith('XMD-TornadoV4-i');
+    },
+    gattAffinity(serviceUuids, _device) {
+        return serviceUuids.has(normalizeUuid(SERVICE_UUID)) ? 110 : 0;
+    },
+    connect: connectQiYiDevice
+};
+registerProtocol(qiyiProtocol);
+export { qiyiProtocol };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/types.d.ts

@@ -0,0 +1,78 @@
+/// <reference types="web-bluetooth" />
+import { Observable } from 'rxjs';
+type SmartCubeMoveEvent = {
+    type: "MOVE";
+    face: number;
+    direction: number;
+    move: string;
+    localTimestamp: number | null;
+    cubeTimestamp: number | null;
+};
+type SmartCubeFaceletsEvent = {
+    type: "FACELETS";
+    facelets: string;
+};
+type SmartCubeGyroEvent = {
+    type: "GYRO";
+    quaternion: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    velocity?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+type SmartCubeBatteryEvent = {
+    type: "BATTERY";
+    batteryLevel: number;
+};
+type SmartCubeProtocolInfo = {
+    id: string;
+    name: string;
+};
+type SmartCubeHardwareEvent = {
+    type: "HARDWARE";
+    hardwareName?: string;
+    softwareVersion?: string;
+    hardwareVersion?: string;
+    productDate?: string;
+    gyroSupported?: boolean;
+};
+type SmartCubeDisconnectEvent = {
+    type: "DISCONNECT";
+};
+type SmartCubeEventMessage = SmartCubeMoveEvent | SmartCubeFaceletsEvent | SmartCubeGyroEvent | SmartCubeBatteryEvent | SmartCubeHardwareEvent | SmartCubeDisconnectEvent;
+type SmartCubeEvent = {
+    timestamp: number;
+} & SmartCubeEventMessage;
+type SmartCubeCommand = {
+    type: "REQUEST_FACELETS";
+} | {
+    type: "REQUEST_BATTERY";
+} | {
+    type: "REQUEST_HARDWARE";
+} | {
+    type: "REQUEST_RESET";
+};
+interface SmartCubeCapabilities {
+    gyroscope: boolean;
+    battery: boolean;
+    facelets: boolean;
+    hardware: boolean;
+    reset: boolean;
+}
+interface SmartCubeConnection {
+    readonly deviceName: string;
+    readonly deviceMAC: string;
+    readonly protocol: SmartCubeProtocolInfo;
+    readonly capabilities: SmartCubeCapabilities;
+    events$: Observable<SmartCubeEvent>;
+    sendCommand(command: SmartCubeCommand): Promise<void>;
+    disconnect(): Promise<void>;
+}
+type MacAddressProvider = (device: BluetoothDevice, isFallbackCall?: boolean) => Promise<string | null>;
+export type { SmartCubeEvent, SmartCubeEventMessage, SmartCubeMoveEvent, SmartCubeFaceletsEvent, SmartCubeGyroEvent, SmartCubeBatteryEvent, SmartCubeProtocolInfo, SmartCubeHardwareEvent, SmartCubeDisconnectEvent, SmartCubeCommand, SmartCubeCapabilities, SmartCubeConnection, MacAddressProvider };

package/bluetooth/vendor/smartcube-web-bluetooth/smartcube/types.js

@@ -0,0 +1 @@
+export {};

package/bluetooth/vendor/smartcube-web-bluetooth/utils.d.ts

@@ -0,0 +1,45 @@
+import { GanCubeMove } from './gan-cube-protocol.js';
+/**
+ * Return current host clock timestamp with millisecond precision
+ * Use monotonic clock when available
+ * @returns Current host clock timestamp in milliseconds
+ */
+declare const now: () => number;
+/**
+ * Use linear regression to fit timestamps reported by cube hardware with host device timestamps
+ * @param cubeMoves List representing window of cube moves to operate on
+ * @returns New copy of move list with fitted cubeTimestamp values
+ */
+declare function cubeTimestampLinearFit(cubeMoves: Array<GanCubeMove>): Array<GanCubeMove>;
+/**
+ * Calculate time skew degree in percent between cube hardware and host device
+ * @param cubeMoves List representing window of cube moves to operate on
+ * @returns Time skew value in percent
+ */
+declare function cubeTimestampCalcSkew(cubeMoves: Array<GanCubeMove>): number;
+/**
+ *
+ * Convert Corner/Edge Permutation/Orientation cube state to the Kociemba facelets representation string
+ *
+ * Example - solved state:
+ *   cp = [0, 1, 2, 3, 4, 5, 6, 7]
+ *   co = [0, 0, 0, 0, 0, 0, 0, 0]
+ *   ep = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+ *   eo = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ *   facelets = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB"
+ * Example - state after F R moves made:
+ *   cp = [0, 5, 2, 1, 7, 4, 6, 3]
+ *   co = [1, 2, 0, 2, 1, 1, 0, 2]
+ *   ep = [1, 9, 2, 3, 11, 8, 6, 7, 4, 5, 10, 0]
+ *   eo = [1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
+ *   facelets = "UUFUUFLLFUUURRRRRRFFRFFDFFDRRBDDBDDBLLDLLDLLDLBBUBBUBB"
+ *
+ * @param cp Corner Permutation
+ * @param co Corner Orientation
+ * @param ep Egde Permutation
+ * @param eo Edge Orientation
+ * @returns Cube state in the Kociemba facelets representation string
+ *
+ */
+declare function toKociembaFacelets(cp: Array<number>, co: Array<number>, ep: Array<number>, eo: Array<number>): string;
+export { now, cubeTimestampLinearFit, cubeTimestampCalcSkew, toKociembaFacelets, };

package/bluetooth/vendor/smartcube-web-bluetooth/utils.js

@@ -0,0 +1,150 @@
+/**
+ * Return current host clock timestamp with millisecond precision
+ * Use monotonic clock when available
+ * @returns Current host clock timestamp in milliseconds
+ */
+const now = typeof window != 'undefined' && typeof window.performance?.now == 'function' ?
+    () => Math.floor(window.performance.now()) :
+    typeof process != 'undefined' && typeof process.hrtime?.bigint == 'function' ?
+        () => Number(process.hrtime.bigint() / 1000000n) :
+        () => Date.now();
+function linregress(X, Y) {
+    var sumX = 0;
+    var sumY = 0;
+    var sumXY = 0;
+    var sumXX = 0;
+    var sumYY = 0;
+    var n = 0;
+    for (var i = 0; i < X.length; i++) {
+        var x = X[i];
+        var y = Y[i];
+        if (x == null || y == null) {
+            continue;
+        }
+        n++;
+        sumX += x;
+        sumY += y;
+        sumXY += x * y;
+        sumXX += x * x;
+        sumYY += y * y;
+    }
+    var varX = n * sumXX - sumX * sumX;
+    var covXY = n * sumXY - sumX * sumY;
+    var slope = varX < 1e-3 ? 1 : covXY / varX;
+    var intercept = n < 1 ? 0 : sumY / n - slope * sumX / n;
+    return [slope, intercept];
+}
+/**
+ * Use linear regression to fit timestamps reported by cube hardware with host device timestamps
+ * @param cubeMoves List representing window of cube moves to operate on
+ * @returns New copy of move list with fitted cubeTimestamp values
+ */
+function cubeTimestampLinearFit(cubeMoves) {
+    var res = [];
+    // Calculate and fix timestamp values for missed and recovered cube moves.
+    if (cubeMoves.length >= 2) {
+        // 1st pass - tail-to-head, align missed move cube timestamps to next move -50ms
+        for (let i = cubeMoves.length - 1; i > 0; i--) {
+            if (cubeMoves[i].cubeTimestamp != null && cubeMoves[i - 1].cubeTimestamp == null)
+                cubeMoves[i - 1].cubeTimestamp = cubeMoves[i].cubeTimestamp - 50;
+        }
+        // 2nd pass - head-to-tail, align missed move cube timestamp to prev move +50ms
+        for (let i = 0; i < cubeMoves.length - 1; i++) {
+            if (cubeMoves[i].cubeTimestamp != null && cubeMoves[i + 1].cubeTimestamp == null)
+                cubeMoves[i + 1].cubeTimestamp = cubeMoves[i].cubeTimestamp + 50;
+        }
+    }
+    // Apply linear regression to the cube timestamps
+    if (cubeMoves.length > 0) {
+        var [slope, intercept] = linregress(cubeMoves.map(m => m.cubeTimestamp), cubeMoves.map(m => m.localTimestamp));
+        var first = Math.round(slope * cubeMoves[0].cubeTimestamp + intercept);
+        cubeMoves.forEach(m => {
+            res.push({
+                face: m.face,
+                direction: m.direction,
+                move: m.move,
+                localTimestamp: m.localTimestamp,
+                cubeTimestamp: Math.round(slope * m.cubeTimestamp + intercept) - first
+            });
+        });
+    }
+    return res;
+}
+/**
+ * Calculate time skew degree in percent between cube hardware and host device
+ * @param cubeMoves List representing window of cube moves to operate on
+ * @returns Time skew value in percent
+ */
+function cubeTimestampCalcSkew(cubeMoves) {
+    if (!cubeMoves.length)
+        return 0;
+    var [slope] = linregress(cubeMoves.map(m => m.localTimestamp), cubeMoves.map(m => m.cubeTimestamp));
+    return Math.round((slope - 1) * 100000) / 1000;
+}
+const CORNER_FACELET_MAP = [
+    [8, 9, 20], // URF
+    [6, 18, 38], // UFL
+    [0, 36, 47], // ULB
+    [2, 45, 11], // UBR
+    [29, 26, 15], // DFR
+    [27, 44, 24], // DLF
+    [33, 53, 42], // DBL
+    [35, 17, 51] // DRB
+];
+const EDGE_FACELET_MAP = [
+    [5, 10], // UR
+    [7, 19], // UF
+    [3, 37], // UL
+    [1, 46], // UB
+    [32, 16], // DR
+    [28, 25], // DF
+    [30, 43], // DL
+    [34, 52], // DB
+    [23, 12], // FR
+    [21, 41], // FL
+    [50, 39], // BL
+    [48, 14] // BR
+];
+/**
+ *
+ * Convert Corner/Edge Permutation/Orientation cube state to the Kociemba facelets representation string
+ *
+ * Example - solved state:
+ *   cp = [0, 1, 2, 3, 4, 5, 6, 7]
+ *   co = [0, 0, 0, 0, 0, 0, 0, 0]
+ *   ep = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+ *   eo = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ *   facelets = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB"
+ * Example - state after F R moves made:
+ *   cp = [0, 5, 2, 1, 7, 4, 6, 3]
+ *   co = [1, 2, 0, 2, 1, 1, 0, 2]
+ *   ep = [1, 9, 2, 3, 11, 8, 6, 7, 4, 5, 10, 0]
+ *   eo = [1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
+ *   facelets = "UUFUUFLLFUUURRRRRRFFRFFDFFDRRBDDBDDBLLDLLDLLDLBBUBBUBB"
+ *
+ * @param cp Corner Permutation
+ * @param co Corner Orientation
+ * @param ep Egde Permutation
+ * @param eo Edge Orientation
+ * @returns Cube state in the Kociemba facelets representation string
+ *
+ */
+function toKociembaFacelets(cp, co, ep, eo) {
+    var faces = "URFDLB";
+    var facelets = [];
+    for (let i = 0; i < 54; i++) {
+        facelets[i] = faces[~~(i / 9)];
+    }
+    for (let i = 0; i < 8; i++) {
+        for (let p = 0; p < 3; p++) {
+            facelets[CORNER_FACELET_MAP[i][(p + co[i]) % 3]] = faces[~~(CORNER_FACELET_MAP[cp[i]][p] / 9)];
+        }
+    }
+    for (let i = 0; i < 12; i++) {
+        for (let p = 0; p < 2; p++) {
+            facelets[EDGE_FACELET_MAP[i][(p + eo[i]) % 2]] = faces[~~(EDGE_FACELET_MAP[ep[i]][p] / 9)];
+        }
+    }
+    return facelets.join('');
+}
+export { now, cubeTimestampLinearFit, cubeTimestampCalcSkew, toKociembaFacelets, };