@codingame/monaco-vscode-extensions-service-override 1.83.8 → 1.83.9

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProcessExtHostProxy.js

@@ -0,0 +1,132 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITerminalService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
+
+let TerminalProcessExtHostProxy = class TerminalProcessExtHostProxy extends Disposable {
+    get onProcessReady() { return this._onProcessReady.event; }
+    constructor(instanceId, _cols, _rows, _terminalService) {
+        super();
+        this.instanceId = instanceId;
+        this._cols = _cols;
+        this._rows = _rows;
+        this._terminalService = _terminalService;
+        this.id = 0;
+        this.shouldPersist = false;
+        this._onProcessData = this._register(( new Emitter()));
+        this.onProcessData = this._onProcessData.event;
+        this._onProcessReady = this._register(( new Emitter()));
+        this._onStart = this._register(( new Emitter()));
+        this.onStart = this._onStart.event;
+        this._onInput = this._register(( new Emitter()));
+        this.onInput = this._onInput.event;
+        this._onBinary = this._register(( new Emitter()));
+        this.onBinary = this._onBinary.event;
+        this._onResize = this._register(( new Emitter()));
+        this.onResize = this._onResize.event;
+        this._onAcknowledgeDataEvent = this._register(( new Emitter()));
+        this.onAcknowledgeDataEvent = this._onAcknowledgeDataEvent.event;
+        this._onShutdown = this._register(( new Emitter()));
+        this.onShutdown = this._onShutdown.event;
+        this._onRequestInitialCwd = this._register(( new Emitter()));
+        this.onRequestInitialCwd = this._onRequestInitialCwd.event;
+        this._onRequestCwd = this._register(( new Emitter()));
+        this.onRequestCwd = this._onRequestCwd.event;
+        this._onDidChangeProperty = this._register(( new Emitter()));
+        this.onDidChangeProperty = this._onDidChangeProperty.event;
+        this._onProcessExit = this._register(( new Emitter()));
+        this.onProcessExit = this._onProcessExit.event;
+        this._pendingInitialCwdRequests = [];
+        this._pendingCwdRequests = [];
+    }
+    emitData(data) {
+        this._onProcessData.fire(data);
+    }
+    emitTitle(title) {
+        this._onDidChangeProperty.fire({ type: "title" , value: title });
+    }
+    emitReady(pid, cwd) {
+        this._onProcessReady.fire({ pid, cwd, windowsPty: undefined });
+    }
+    emitProcessProperty({ type, value }) {
+        switch (type) {
+            case "cwd" :
+                this.emitCwd(value);
+                break;
+            case "initialCwd" :
+                this.emitInitialCwd(value);
+                break;
+            case "title" :
+                this.emitTitle(value);
+                break;
+            case "overrideDimensions" :
+                this.emitOverrideDimensions(value);
+                break;
+            case "resolvedShellLaunchConfig" :
+                this.emitResolvedShellLaunchConfig(value);
+                break;
+        }
+    }
+    emitExit(exitCode) {
+        this._onProcessExit.fire(exitCode);
+        this.dispose();
+    }
+    emitOverrideDimensions(dimensions) {
+        this._onDidChangeProperty.fire({ type: "overrideDimensions" , value: dimensions });
+    }
+    emitResolvedShellLaunchConfig(shellLaunchConfig) {
+        this._onDidChangeProperty.fire({ type: "resolvedShellLaunchConfig" , value: shellLaunchConfig });
+    }
+    emitInitialCwd(initialCwd) {
+        while (this._pendingInitialCwdRequests.length > 0) {
+            this._pendingInitialCwdRequests.pop()(initialCwd);
+        }
+    }
+    emitCwd(cwd) {
+        while (this._pendingCwdRequests.length > 0) {
+            this._pendingCwdRequests.pop()(cwd);
+        }
+    }
+    async start() {
+        return this._terminalService.requestStartExtensionTerminal(this, this._cols, this._rows);
+    }
+    shutdown(immediate) {
+        this._onShutdown.fire(immediate);
+    }
+    input(data) {
+        this._onInput.fire(data);
+    }
+    resize(cols, rows) {
+        this._onResize.fire({ cols, rows });
+    }
+    clearBuffer() {
+    }
+    acknowledgeDataEvent() {
+    }
+    async setUnicodeVersion(version) {
+    }
+    async processBinary(data) {
+        this._onBinary.fire(data);
+    }
+    getInitialCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestInitialCwd.fire();
+            this._pendingInitialCwdRequests.push(resolve);
+        }));
+    }
+    getCwd() {
+        return ( new Promise(resolve => {
+            this._onRequestCwd.fire();
+            this._pendingCwdRequests.push(resolve);
+        }));
+    }
+    async refreshProperty(type) {
+    }
+    async updateProperty(type, value) {
+    }
+};
+TerminalProcessExtHostProxy = ( __decorate([
+    ( __param(3, ITerminalService))
+], TerminalProcessExtHostProxy));
+
+export { TerminalProcessExtHostProxy };

package/vscode/src/vs/workbench/contrib/testing/common/getComputedState.js

@@ -0,0 +1,103 @@
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { statePriority, makeEmptyCounts, maxPriority } from './testingStates.js';
+
+const isDurationAccessor = (accessor) => 'getOwnDuration' in accessor;
+const getComputedState = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedState(node);
+    if (computed === undefined || force) {
+        computed = accessor.getOwnState(node) ?? 0 ;
+        let childrenCount = 0;
+        const stateMap = makeEmptyCounts();
+        for (const child of accessor.getChildren(node)) {
+            const childComputed = getComputedState(accessor, child);
+            childrenCount++;
+            stateMap[childComputed]++;
+            computed = childComputed === 5  && computed === 0
+                ? 5  : maxPriority(computed, childComputed);
+        }
+        if (childrenCount > LARGE_NODE_THRESHOLD) {
+            largeNodeChildrenStates.set(node, stateMap);
+        }
+        accessor.setComputedState(node, computed);
+    }
+    return computed;
+};
+const getComputedDuration = (accessor, node, force = false) => {
+    let computed = accessor.getCurrentComputedDuration(node);
+    if (computed === undefined || force) {
+        const own = accessor.getOwnDuration(node);
+        if (own !== undefined) {
+            computed = own;
+        }
+        else {
+            computed = undefined;
+            for (const child of accessor.getChildren(node)) {
+                const d = getComputedDuration(accessor, child);
+                if (d !== undefined) {
+                    computed = (computed || 0) + d;
+                }
+            }
+        }
+        accessor.setComputedDuration(node, computed);
+    }
+    return computed;
+};
+const LARGE_NODE_THRESHOLD = 64;
+const largeNodeChildrenStates = ( new WeakMap());
+const refreshComputedState = (accessor, node, explicitNewComputedState, refreshDuration = true) => {
+    const oldState = accessor.getCurrentComputedState(node);
+    const oldPriority = statePriority[oldState];
+    const newState = explicitNewComputedState ?? getComputedState(accessor, node, true);
+    const newPriority = statePriority[newState];
+    const toUpdate = ( new Set());
+    if (newPriority !== oldPriority) {
+        accessor.setComputedState(node, newState);
+        toUpdate.add(node);
+        let moveFromState = oldState;
+        let moveToState = newState;
+        for (const parent of accessor.getParents(node)) {
+            const lnm = largeNodeChildrenStates.get(parent);
+            if (lnm) {
+                lnm[moveFromState]--;
+                lnm[moveToState]++;
+            }
+            const prev = accessor.getCurrentComputedState(parent);
+            if (newPriority > oldPriority) {
+                if (prev !== undefined && statePriority[prev] >= newPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveToState] > 1) {
+                    break;
+                }
+                accessor.setComputedState(parent, newState);
+                toUpdate.add(parent);
+            }
+            else  {
+                if (prev === undefined || statePriority[prev] > oldPriority) {
+                    break;
+                }
+                if (lnm && lnm[moveFromState] > 0) {
+                    break;
+                }
+                moveToState = getComputedState(accessor, parent, true);
+                accessor.setComputedState(parent, moveToState);
+                toUpdate.add(parent);
+            }
+            moveFromState = prev;
+        }
+    }
+    if (isDurationAccessor(accessor) && refreshDuration) {
+        for (const parent of Iterable.concat(Iterable.single(node), accessor.getParents(node))) {
+            const oldDuration = accessor.getCurrentComputedDuration(parent);
+            const newDuration = getComputedDuration(accessor, parent, true);
+            if (oldDuration === newDuration) {
+                break;
+            }
+            accessor.setComputedDuration(parent, newDuration);
+            toUpdate.add(parent);
+        }
+    }
+    return toUpdate;
+};
+
+export { refreshComputedState };

package/vscode/src/vs/workbench/contrib/testing/common/observableValue.js

@@ -0,0 +1,28 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class MutableObservableValue extends Disposable {
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        if (v !== this._value) {
+            this._value = v;
+            this.changeEmitter.fire(v);
+        }
+    }
+    static stored(stored, defaultValue) {
+        const o = ( new MutableObservableValue(stored.get(defaultValue)));
+        o._register(stored);
+        o._register(o.onDidChange(value => stored.store(value)));
+        return o;
+    }
+    constructor(_value) {
+        super();
+        this._value = _value;
+        this.changeEmitter = this._register(( new Emitter()));
+        this.onDidChange = this.changeEmitter.event;
+    }
+}
+
+export { MutableObservableValue };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.js

@@ -0,0 +1,25 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+
+class TestCoverage {
+    constructor(accessor) {
+        this.accessor = accessor;
+    }
+    async getAllFiles(token = CancellationToken.None) {
+        if (!this.fileCoverage) {
+            this.fileCoverage = this.accessor.provideFileCoverage(token);
+        }
+        try {
+            return await this.fileCoverage;
+        }
+        catch (e) {
+            this.fileCoverage = undefined;
+            throw e;
+        }
+    }
+    async getUri(uri, token = CancellationToken.None) {
+        const files = await this.getAllFiles(token);
+        return files.find(f => ( f.uri.toString()) === ( uri.toString()));
+    }
+}
+
+export { TestCoverage };

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -0,0 +1,336 @@
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { removeAnsiEscapeCodes } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { refreshComputedState } from './getComputedState.js';
+import { MutableObservableValue } from './observableValue.js';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+import { makeEmptyCounts, terminalStatePriorities, maxPriority } from './testingStates.js';
+import { TestResultItem, getMarkId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+
+({
+    buffers: [],
+    length: 0,
+    onDidWriteData: Event.None,
+    endPromise: Promise.resolve(),
+    getRange: () => VSBuffer.alloc(0),
+    getRangeIter: () => [],
+});
+class TaskRawOutput {
+    constructor() {
+        this.writeDataEmitter = ( new Emitter());
+        this.endDeferred = ( new DeferredPromise());
+        this.offset = 0;
+        this.onDidWriteData = this.writeDataEmitter.event;
+        this.endPromise = this.endDeferred.p;
+        this.buffers = [];
+    }
+    get length() {
+        return this.offset;
+    }
+    getRange(start, length) {
+        const buf = VSBuffer.alloc(length);
+        let bufLastWrite = 0;
+        for (const chunk of this.getRangeIter(start, length)) {
+            buf.buffer.set(chunk.buffer, bufLastWrite);
+            bufLastWrite += chunk.byteLength;
+        }
+        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
+    }
+    *getRangeIter(start, length) {
+        let soFar = 0;
+        let internalLastRead = 0;
+        for (const b of this.buffers) {
+            if (internalLastRead + b.byteLength <= start) {
+                internalLastRead += b.byteLength;
+                continue;
+            }
+            const bstart = Math.max(0, start - internalLastRead);
+            const bend = Math.min(b.byteLength, bstart + length - soFar);
+            yield b.slice(bstart, bend);
+            soFar += bend - bstart;
+            internalLastRead += b.byteLength;
+            if (soFar === length) {
+                break;
+            }
+        }
+    }
+    append(data, marker) {
+        const offset = this.offset;
+        let length = data.byteLength;
+        if (marker === undefined) {
+            this.push(data);
+            return { offset, length };
+        }
+        const start = VSBuffer.fromString(getMarkCode(marker, true));
+        const end = VSBuffer.fromString(getMarkCode(marker, false));
+        length += start.byteLength + end.byteLength;
+        this.push(start);
+        let trimLen = data.byteLength;
+        for (; trimLen > 0; trimLen--) {
+            const last = data.buffer[trimLen - 1];
+            if (last !== 13  && last !== 10 ) {
+                break;
+            }
+        }
+        this.push(data.slice(0, trimLen));
+        this.push(end);
+        this.push(data.slice(trimLen));
+        return { offset, length };
+    }
+    push(data) {
+        if (data.byteLength === 0) {
+            return;
+        }
+        this.buffers.push(data);
+        this.writeDataEmitter.fire(data);
+        this.offset += data.byteLength;
+    }
+    end() {
+        this.endDeferred.complete();
+    }
+}
+const getMarkCode = (marker, start) => `\x1b]633;SetMark;Id=${getMarkId(marker, start)};Hidden\x07`;
+const itemToNode = (controllerId, item, parent) => ({
+    controllerId,
+    expand: 0 ,
+    item: { ...item },
+    children: [],
+    tasks: [],
+    ownComputedState: 0 ,
+    computedState: 0 ,
+});
+class LiveTestResult extends Disposable {
+    get completedAt() {
+        return this._completedAt;
+    }
+    get tests() {
+        return ( this.testById.values());
+    }
+    constructor(id, persist, request) {
+        super();
+        this.id = id;
+        this.persist = persist;
+        this.request = request;
+        this.completeEmitter = this._register(( new Emitter()));
+        this.newTaskEmitter = this._register(( new Emitter()));
+        this.endTaskEmitter = this._register(( new Emitter()));
+        this.changeEmitter = this._register(( new Emitter()));
+        this.testById = ( new Map());
+        this.testMarkerCounter = 0;
+        this.startedAt = Date.now();
+        this.onChange = this.changeEmitter.event;
+        this.onComplete = this.completeEmitter.event;
+        this.onNewTask = this.newTaskEmitter.event;
+        this.onEndTask = this.endTaskEmitter.event;
+        this.tasks = [];
+        this.name = ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testResult',
+            'runFinished',
+            'Test run at {0}',
+            ( new Date()).toLocaleString(language)
+        ));
+        this.counts = makeEmptyCounts();
+        this.computedStateAccessor = {
+            getOwnState: i => i.ownComputedState,
+            getCurrentComputedState: i => i.computedState,
+            setComputedState: (i, s) => i.computedState = s,
+            getChildren: i => i.children,
+            getParents: i => {
+                const { testById: testByExtId } = this;
+                return (function* () {
+                    const parentId = TestId.fromString(i.item.extId).parentId;
+                    if (parentId) {
+                        for (const id of parentId.idsToRoot()) {
+                            yield testByExtId.get(( id.toString()));
+                        }
+                    }
+                })();
+            },
+        };
+        this.doSerialize = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serializeWithoutMessages)),
+        })));
+        this.doSerializeWithMessages = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serialize)),
+        })));
+    }
+    getStateById(extTestId) {
+        return this.testById.get(extTestId);
+    }
+    appendOutput(output, taskId, location, testId) {
+        const preview = output.byteLength > 100 ? ( output.slice(0, 100).toString()) + '…' : ( output.toString());
+        let marker;
+        if (testId || location) {
+            marker = this.testMarkerCounter++;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        const { offset, length } = task.output.append(output, marker);
+        const message = {
+            location,
+            message: removeAnsiEscapeCodes(preview),
+            offset,
+            length,
+            marker,
+            type: 1 ,
+        };
+        const test = testId && this.testById.get(testId);
+        if (test) {
+            test.tasks[index].messages.push(message);
+            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
+        }
+        else {
+            task.otherMessages.push(message);
+        }
+    }
+    addTask(task) {
+        this.tasks.push({ ...task, coverage: this._register(( new MutableObservableValue(undefined))), otherMessages: [], output: ( new TaskRawOutput()) });
+        for (const test of this.tests) {
+            test.tasks.push({ duration: undefined, messages: [], state: 0  });
+        }
+        this.newTaskEmitter.fire(this.tasks.length - 1);
+    }
+    addTestChainToRun(controllerId, chain) {
+        let parent = this.testById.get(chain[0].extId);
+        if (!parent) {
+            parent = this.addTestToRun(controllerId, chain[0], null);
+        }
+        for (let i = 1; i < chain.length; i++) {
+            parent = this.addTestToRun(controllerId, chain[i], parent.item.extId);
+        }
+        return undefined;
+    }
+    updateState(testId, taskId, state, duration) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const oldTerminalStatePrio = terminalStatePriorities[entry.tasks[index].state];
+        const newTerminalStatePrio = terminalStatePriorities[state];
+        if (oldTerminalStatePrio !== undefined &&
+            (newTerminalStatePrio === undefined || newTerminalStatePrio < oldTerminalStatePrio)) {
+            return;
+        }
+        this.fireUpdateAndRefresh(entry, index, state, duration);
+    }
+    appendMessage(testId, taskId, message) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
+        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
+    }
+    markTaskComplete(taskId) {
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        task.running = false;
+        task.output.end();
+        this.setAllToState(0 , taskId, t => t.state === 1  || t.state === 2 );
+        this.endTaskEmitter.fire(index);
+    }
+    markComplete() {
+        if (this._completedAt !== undefined) {
+            throw new Error('cannot complete a test result multiple times');
+        }
+        for (const task of this.tasks) {
+            if (task.running) {
+                this.markTaskComplete(task.id);
+            }
+        }
+        this._completedAt = Date.now();
+        this.completeEmitter.fire();
+    }
+    markRetired(testIds) {
+        for (const [id, test] of this.testById) {
+            if (!test.retired && (!testIds || testIds.hasKeyOrParent(TestId.fromString(id).path))) {
+                test.retired = true;
+                this.changeEmitter.fire({ reason: 0 , item: test, result: this });
+            }
+        }
+    }
+    toJSON() {
+        return this.completedAt && this.persist ? this.doSerialize.value : undefined;
+    }
+    toJSONWithMessages() {
+        return this.completedAt && this.persist ? this.doSerializeWithMessages.value : undefined;
+    }
+    setAllToState(state, taskId, when) {
+        const index = this.mustGetTaskIndex(taskId);
+        for (const test of ( this.testById.values())) {
+            if (when(test.tasks[index], test)) {
+                this.fireUpdateAndRefresh(test, index, state);
+            }
+        }
+    }
+    fireUpdateAndRefresh(entry, taskIndex, newState, newOwnDuration) {
+        const previousOwnComputed = entry.ownComputedState;
+        const previousOwnDuration = entry.ownDuration;
+        const changeEvent = {
+            item: entry,
+            result: this,
+            reason: 1 ,
+            previousState: previousOwnComputed,
+            previousOwnDuration: previousOwnDuration,
+        };
+        entry.tasks[taskIndex].state = newState;
+        if (newOwnDuration !== undefined) {
+            entry.tasks[taskIndex].duration = newOwnDuration;
+            entry.ownDuration = Math.max(entry.ownDuration || 0, newOwnDuration);
+        }
+        const newOwnComputed = maxPriority(...( entry.tasks.map(t => t.state)));
+        if (newOwnComputed === previousOwnComputed) {
+            if (newOwnDuration !== previousOwnDuration) {
+                this.changeEmitter.fire(changeEvent);
+            }
+            return;
+        }
+        entry.ownComputedState = newOwnComputed;
+        this.counts[previousOwnComputed]--;
+        this.counts[newOwnComputed]++;
+        refreshComputedState(this.computedStateAccessor, entry).forEach(t => this.changeEmitter.fire(t === entry ? changeEvent : {
+            item: t,
+            result: this,
+            reason: 0 ,
+        }));
+    }
+    addTestToRun(controllerId, item, parent) {
+        const node = itemToNode(controllerId, item);
+        this.testById.set(item.extId, node);
+        this.counts[0 ]++;
+        if (parent) {
+            this.testById.get(parent)?.children.push(node);
+        }
+        if (this.tasks.length) {
+            for (let i = 0; i < this.tasks.length; i++) {
+                node.tasks.push({ duration: undefined, messages: [], state: 0  });
+            }
+        }
+        return node;
+    }
+    mustGetTaskIndex(taskId) {
+        const index = this.tasks.findIndex(t => t.id === taskId);
+        if (index === -1) {
+            throw new Error(`Unknown task ${taskId} in updateState`);
+        }
+        return index;
+    }
+}
+
+export { LiveTestResult, TaskRawOutput };

package/vscode/src/vs/workbench/contrib/testing/common/testingStates.js

@@ -0,0 +1,46 @@
+const statePriority = {
+    [2 ]: 6,
+    [6 ]: 5,
+    [4 ]: 4,
+    [1 ]: 3,
+    [3 ]: 2,
+    [0 ]: 0,
+    [5 ]: 1,
+};
+Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
+    const state = Number(stateStr);
+    acc[state] = { statusNode: true, state, priority };
+    return acc;
+}, {});
+const cmpPriority = (a, b) => statePriority[b] - statePriority[a];
+const maxPriority = (...states) => {
+    switch (states.length) {
+        case 0:
+            return 0 ;
+        case 1:
+            return states[0];
+        case 2:
+            return statePriority[states[0]] > statePriority[states[1]] ? states[0] : states[1];
+        default: {
+            let max = states[0];
+            for (let i = 1; i < states.length; i++) {
+                if (statePriority[max] < statePriority[states[i]]) {
+                    max = states[i];
+                }
+            }
+            return max;
+        }
+    }
+};
+const statesInOrder = ( ( Object.keys(statePriority)).map(s => Number(s))).sort(cmpPriority);
+const terminalStatePriorities = {
+    [3 ]: 0,
+    [5 ]: 1,
+    [4 ]: 2,
+    [6 ]: 3,
+};
+const makeEmptyCounts = () => {
+    return ( new Uint32Array(statesInOrder.length));
+};
+
+export { cmpPriority, makeEmptyCounts, maxPriority, statePriority, statesInOrder, terminalStatePriorities };