@rstest/core 0.0.1 → 0.0.2

package/dist/813.js

@@ -10,6 +10,7 @@ export const __webpack_modules__ = {
         var node_console__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("node:console");
         var node_util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("node:util");
         var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
+        const RealDate = Date;
         function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
             const getConsoleTrace = ()=>{
                 const limit = Error.stackTraceLimit;
@@ -92,12 +93,12 @@ export const __webpack_modules__ = {
                 }
                 time(label = 'default') {
                     if (null != this._timers[label]) return;
-                    this._timers[label] = new Date();
+                    this._timers[label] = new RealDate();
                 }
                 timeEnd(label = 'default') {
                     const startTime = this._timers[label];
                     if (null != startTime) {
-                        const endTime = Date.now();
+                        const endTime = RealDate.now();
                         const time = endTime - startTime.getTime();
                         this._log('time', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(`${label}: ${(0, _utils__WEBPACK_IMPORTED_MODULE_3__.AS)(time)}`));
                         delete this._timers[label];
@@ -106,7 +107,7 @@ export const __webpack_modules__ = {
                 timeLog(label = 'default', ...data) {
                     const startTime = this._timers[label];
                     if (null != startTime) {
-                        const endTime = new Date();
+                        const endTime = new RealDate();
                         const time = endTime.getTime() - startTime.getTime();
                         this._log('time', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(`${label}: ${(0, _utils__WEBPACK_IMPORTED_MODULE_3__.AS)(time)}`, ...data));
                     }

package/dist/{773.js → 867.js}

@@ -1,5 +1,5 @@
 export const __webpack_ids__ = [
-    "773"
+    "867"
 ];
 export const __webpack_modules__ = {
     "./src/runtime/api/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -9,6 +9,7 @@ export const __webpack_modules__ = {
         var expect_ = __webpack_require__("@vitest/expect");
         var src_utils = __webpack_require__("./src/utils/index.ts");
         var external_chai_ = __webpack_require__("chai");
+        var external_node_timers_ = __webpack_require__("node:timers");
         const unsupported = [
             'matchSnapshot',
             'toMatchSnapshot',
@@ -52,10 +53,10 @@ export const __webpack_modules__ = {
                                             clearTimeout(timeoutId);
                                         } catch (err) {
                                             lastError = err;
-                                            if (!external_chai_.util.flag(assertion, '_isLastPollAttempt')) intervalId = setTimeout(check, interval);
+                                            if (!external_chai_.util.flag(assertion, '_isLastPollAttempt')) intervalId = (0, external_node_timers_.setTimeout)(check, interval);
                                         }
                                     };
-                                    timeoutId = setTimeout(()=>{
+                                    timeoutId = (0, external_node_timers_.setTimeout)(()=>{
                                         clearTimeout(intervalId);
                                         external_chai_.util.flag(assertion, '_isLastPollAttempt', true);
                                         const rejectWithCause = (cause)=>{
@@ -568,7 +569,7 @@ export const __webpack_modules__ = {
             return async (...args)=>{
                 let timeoutId;
                 const timeoutPromise = new Promise((_, reject)=>{
-                    timeoutId = setTimeout(()=>reject(makeError(`${name} timed out in ${timeout}ms`, stackTraceError)), timeout);
+                    timeoutId = (0, external_node_timers_.setTimeout)(()=>reject(makeError(`${name} timed out in ${timeout}ms`, stackTraceError)), timeout);
                 });
                 try {
                     const result = await Promise.race([
@@ -606,6 +607,7 @@ export const __webpack_modules__ = {
                     } else queue.push(task);
                 });
         }
+        const RealDate = Date;
         class TestRunner {
             _test;
             workerState;
@@ -797,7 +799,7 @@ export const __webpack_modules__ = {
                             errors.push(...(0, runtime_util.o)(error));
                         }
                     } else {
-                        const start = Date.now();
+                        const start = RealDate.now();
                         let result;
                         let retryCount = 0;
                         do {
@@ -808,12 +810,12 @@ export const __webpack_modules__ = {
                             };
                             retryCount++;
                         }while (retryCount <= retry && 'fail' === result.status);
-                        result.duration = Date.now() - start;
+                        result.duration = RealDate.now() - start;
                         hooks.onTestCaseResult?.(result);
                         results.push(result);
                     }
                 };
-                const start = Date.now();
+                const start = RealDate.now();
                 if (0 === tests.length) {
                     if (passWithNoTests) return {
                         testPath,
@@ -846,7 +848,7 @@ export const __webpack_modules__ = {
                     results,
                     snapshotResult,
                     errors,
-                    duration: Date.now() - start
+                    duration: RealDate.now() - start
                 };
             }
             resetCurrentTest() {
@@ -1316,165 +1318,119 @@ export const __webpack_modules__ = {
                 }
             };
         }
-        function dist_assert(condition, message) {
-            if (!condition) throw new Error(message);
-        }
-        function isType(type, value) {
-            return typeof value === type;
-        }
-        function isPromise(value) {
-            return value instanceof Promise;
-        }
-        function dist_define(obj, key, descriptor) {
-            Object.defineProperty(obj, key, descriptor);
-        }
-        function defineValue(obj, key, value) {
-            dist_define(obj, key, {
-                value,
-                configurable: !0,
-                writable: !0
-            });
-        }
-        var SYMBOL_STATE = Symbol.for("tinyspy:spy");
-        var spies = /* @__PURE__ */ new Set(), dist_reset = (state)=>{
-            state.called = !1, state.callCount = 0, state.calls = [], state.results = [], state.resolves = [], state.next = [];
-        }, defineState = (spy2)=>(dist_define(spy2, SYMBOL_STATE, {
-                value: {
-                    reset: ()=>dist_reset(spy2[SYMBOL_STATE])
+        var fake_timers_src = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@14.0.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
+        const fakeTimers_RealDate = Date;
+        class FakeTimers {
+            _clock;
+            _config;
+            _fakingTime;
+            _fakeTimers;
+            constructor({ global, config = {} }){
+                this._config = config;
+                this._fakingTime = false;
+                this._fakeTimers = (0, fake_timers_src.withGlobal)(global);
+            }
+            clearAllTimers() {
+                if (this._fakingTime) this._clock.reset();
+            }
+            dispose() {
+                this.useRealTimers();
+            }
+            runAllTimers() {
+                if (this._checkFakeTimers()) this._clock.runAll();
+            }
+            async runAllTimersAsync() {
+                if (this._checkFakeTimers()) await this._clock.runAllAsync();
+            }
+            runOnlyPendingTimers() {
+                if (this._checkFakeTimers()) this._clock.runToLast();
+            }
+            async runOnlyPendingTimersAsync() {
+                if (this._checkFakeTimers()) await this._clock.runToLastAsync();
+            }
+            advanceTimersToNextTimer(steps = 1) {
+                if (this._checkFakeTimers()) for(let i = steps; i > 0; i--){
+                    this._clock.next();
+                    this._clock.tick(0);
+                    if (0 === this._clock.countTimers()) break;
                 }
-            }), spy2[SYMBOL_STATE]), getInternalState = (spy2)=>spy2[SYMBOL_STATE] || defineState(spy2);
-        function createInternalSpy(cb) {
-            dist_assert(isType("function", cb) || isType("undefined", cb), "cannot spy on a non-function value");
-            let fn = function(...args) {
-                let state2 = getInternalState(fn);
-                state2.called = !0, state2.callCount++, state2.calls.push(args);
-                let next = state2.next.shift();
-                if (next) {
-                    state2.results.push(next);
-                    let [type2, result2] = next;
-                    if ("ok" === type2) return result2;
-                    throw result2;
+            }
+            async advanceTimersToNextTimerAsync(steps = 1) {
+                if (this._checkFakeTimers()) for(let i = steps; i > 0; i--){
+                    await this._clock.nextAsync();
+                    await this._clock.tickAsync(0);
+                    if (0 === this._clock.countTimers()) break;
                 }
-                let result, type = "ok", resultIndex = state2.results.length;
-                if (state2.impl) try {
-                    new.target ? result = Reflect.construct(state2.impl, args, new.target) : result = state2.impl.apply(this, args), type = "ok";
-                } catch (err) {
-                    throw result = err, type = "error", state2.results.push([
-                        type,
-                        err
-                    ]), err;
+            }
+            advanceTimersByTime(msToRun) {
+                if (this._checkFakeTimers()) this._clock.tick(msToRun);
+            }
+            async advanceTimersByTimeAsync(msToRun) {
+                if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);
+            }
+            advanceTimersToNextFrame() {
+                if (this._checkFakeTimers()) this._clock.runToFrame();
+            }
+            runAllTicks() {
+                if (this._checkFakeTimers()) this._clock.runMicrotasks();
+            }
+            useRealTimers() {
+                if (this._fakingTime) {
+                    this._clock.uninstall();
+                    this._fakingTime = false;
                 }
-                let resultTuple = [
-                    type,
-                    result
-                ];
-                return isPromise(result) && result.then((r)=>state2.resolves[resultIndex] = [
-                        "ok",
-                        r
-                    ], (e)=>state2.resolves[resultIndex] = [
-                        "error",
-                        e
-                    ]), state2.results.push(resultTuple), result;
-            };
-            defineValue(fn, "_isMockFunction", !0), defineValue(fn, "length", cb ? cb.length : 0), defineValue(fn, "name", cb && cb.name || "spy");
-            let state = getInternalState(fn);
-            return state.reset(), state.impl = cb, fn;
-        }
-        function isMockFunction(obj) {
-            return !!obj && !0 === obj._isMockFunction;
-        }
-        var getDescriptor = (obj, method)=>{
-            let objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
-            if (objDescriptor) return [
-                obj,
-                objDescriptor
-            ];
-            let currentProto = Object.getPrototypeOf(obj);
-            for(; null !== currentProto;){
-                let descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
-                if (descriptor) return [
-                    currentProto,
-                    descriptor
-                ];
-                currentProto = Object.getPrototypeOf(currentProto);
             }
-        }, setPototype = (fn, val)=>{
-            null != val && "function" == typeof val && null != val.prototype && Object.setPrototypeOf(fn.prototype, val.prototype);
-        };
-        function internalSpyOn(obj, methodName, mock) {
-            dist_assert(!isType("undefined", obj), "spyOn could not find an object to spy upon"), dist_assert(isType("object", obj) || isType("function", obj), "cannot spyOn on a primitive value");
-            let [accessName, accessType] = (()=>{
-                if (!isType("object", methodName)) return [
-                    methodName,
-                    "value"
-                ];
-                if ("getter" in methodName && "setter" in methodName) throw new Error("cannot spy on both getter and setter");
-                if ("getter" in methodName) return [
-                    methodName.getter,
-                    "get"
-                ];
-                if ("setter" in methodName) return [
-                    methodName.setter,
-                    "set"
-                ];
-                throw new Error("specify getter or setter to spy on");
-            })(), [originalDescriptorObject, originalDescriptor] = getDescriptor(obj, accessName) || [];
-            dist_assert(originalDescriptor || accessName in obj, `${String(accessName)} does not exist`);
-            let ssr = !1;
-            "value" === accessType && originalDescriptor && !originalDescriptor.value && originalDescriptor.get && (accessType = "get", ssr = !0, mock = originalDescriptor.get());
-            let original;
-            originalDescriptor ? original = originalDescriptor[accessType] : "value" !== accessType ? original = ()=>obj[accessName] : original = obj[accessName], original && isSpyFunction(original) && (original = original[SYMBOL_STATE].getOriginal());
-            let reassign = (cb)=>{
-                let { value, ...desc } = originalDescriptor || {
-                    configurable: !0,
-                    writable: !0
-                };
-                "value" !== accessType && delete desc.writable, desc[accessType] = cb, dist_define(obj, accessName, desc);
-            }, restore = ()=>{
-                originalDescriptorObject !== obj ? Reflect.deleteProperty(obj, accessName) : originalDescriptor && !original ? dist_define(obj, accessName, originalDescriptor) : reassign(original);
-            };
-            mock || (mock = original);
-            let spy2 = wrap(createInternalSpy(mock), mock);
-            "value" === accessType && setPototype(spy2, original);
-            let state = spy2[SYMBOL_STATE];
-            return defineValue(state, "restore", restore), defineValue(state, "getOriginal", ()=>ssr ? original() : original), defineValue(state, "willCall", (newCb)=>(state.impl = newCb, spy2)), reassign(ssr ? ()=>(setPototype(spy2, mock), spy2) : spy2), spies.add(spy2), spy2;
-        }
-        var ignoreProperties = /* @__PURE__ */ new Set([
-            "length",
-            "name",
-            "prototype"
-        ]);
-        function getAllProperties(original) {
-            let properties = /* @__PURE__ */ new Set(), descriptors2 = {};
-            for(; original && original !== Object.prototype && original !== Function.prototype;){
-                let ownProperties = [
-                    ...Object.getOwnPropertyNames(original),
-                    ...Object.getOwnPropertySymbols(original)
-                ];
-                for (let prop of ownProperties)descriptors2[prop] || ignoreProperties.has(prop) || (properties.add(prop), descriptors2[prop] = Object.getOwnPropertyDescriptor(original, prop));
-                original = Object.getPrototypeOf(original);
+            useFakeTimers(fakeTimersConfig = {}) {
+                if (this._fakingTime) this._clock.uninstall();
+                const toFake = Object.keys(this._fakeTimers.timers).filter((timer)=>'nextTick' !== timer && 'queueMicrotask' !== timer);
+                const isChildProcess = 'undefined' != typeof process && !!process.send;
+                if (this._config?.toFake?.includes('nextTick') && isChildProcess) throw new Error('process.nextTick cannot be mocked inside child_process');
+                this._clock = this._fakeTimers.install({
+                    loopLimit: 10000,
+                    shouldClearNativeTimers: true,
+                    now: Date.now(),
+                    toFake: [
+                        ...toFake
+                    ],
+                    ignoreMissingTimers: true,
+                    ...fakeTimersConfig
+                });
+                this._fakingTime = true;
             }
-            return {
-                properties,
-                descriptors: descriptors2
-            };
-        }
-        function wrap(mock, original) {
-            if (!original || SYMBOL_STATE in original) return mock;
-            let { properties, descriptors: descriptors2 } = getAllProperties(original);
-            for (let key of properties){
-                let descriptor = descriptors2[key];
-                getDescriptor(mock, key) || dist_define(mock, key, descriptor);
+            reset() {
+                if (this._checkFakeTimers()) {
+                    const { now } = this._clock;
+                    this._clock.reset();
+                    this._clock.setSystemTime(now);
+                }
+            }
+            setSystemTime(now) {
+                if (this._checkFakeTimers()) this._clock.setSystemTime(now);
+            }
+            getRealSystemTime() {
+                return fakeTimers_RealDate.now();
+            }
+            now() {
+                if (this._fakingTime) return this._clock.now;
+                return Date.now();
+            }
+            getTimerCount() {
+                if (this._checkFakeTimers()) return this._clock.countTimers();
+                return 0;
+            }
+            _checkFakeTimers() {
+                if (!this._fakingTime) throw new Error('Timers are not mocked. Try calling "rstest.useFakeTimers()" first.');
+                return this._fakingTime;
+            }
+            isFakeTimers() {
+                return this._fakingTime;
             }
-            return mock;
-        }
-        function isSpyFunction(obj) {
-            return isMockFunction(obj) && "getOriginal" in obj[SYMBOL_STATE];
         }
+        var dist = __webpack_require__("../../node_modules/.pnpm/tinyspy@4.0.3/node_modules/tinyspy/dist/index.js");
         let callOrder = 0;
         const mocks = new Set();
         const wrapSpy = (obj, methodName, mockFn)=>{
-            const spyImpl = internalSpyOn(obj, methodName, mockFn);
+            const spyImpl = (0, dist.XD)(obj, methodName, mockFn);
             const spyFn = spyImpl;
             let mockImplementationOnce = [];
             let implementation = mockFn;
@@ -1485,7 +1441,7 @@ export const __webpack_modules__ = {
                     invocationCallOrder: []
                 });
             let mockState = initMockState();
-            const spyState = getInternalState(spyImpl);
+            const spyState = (0, dist.eN)(spyImpl);
             spyFn.getMockName = ()=>mockName || methodName;
             spyFn.mockName = (name)=>{
                 mockName = name;
@@ -1597,7 +1553,7 @@ export const __webpack_modules__ = {
                 [defaultName]: mockFn
             }, defaultName, mockFn);
         };
-        const spy_spyOn = (obj, methodName, accessType)=>{
+        const spyOn = (obj, methodName, accessType)=>{
             const accessTypeMap = {
                 get: 'getter',
                 set: 'setter'
@@ -1607,14 +1563,21 @@ export const __webpack_modules__ = {
             } : methodName;
             return wrapSpy(obj, method);
         };
-        const spy_isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
+        const isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
         const createRstestUtilities = ()=>{
             const originalEnvValues = new Map();
             const originalGlobalValues = new Map();
+            let _timers;
+            const timers = ()=>{
+                if (!_timers) _timers = new FakeTimers({
+                    global: globalThis
+                });
+                return _timers;
+            };
             const rstest = {
                 fn: spy_fn,
-                spyOn: spy_spyOn,
-                isMockFunction: spy_isMockFunction,
+                spyOn: spyOn,
+                isMockFunction: isMockFunction,
                 clearAllMocks: ()=>{
                     for (const mock of mocks)mock.mockClear();
                     return rstest;
@@ -1633,6 +1596,7 @@ export const __webpack_modules__ = {
                 doUnMock: ()=>{},
                 importMock: async ()=>({}),
                 importActual: async ()=>({}),
+                requireActual: ()=>({}),
                 resetModules: ()=>rstest,
                 stubEnv: (name, value)=>{
                     if (!originalEnvValues.has(name)) originalEnvValues.set(name, process.env[name]);
@@ -1663,6 +1627,65 @@ export const __webpack_modules__ = {
                     });
                     originalGlobalValues.clear();
                     return rstest;
+                },
+                useFakeTimers: (opts)=>{
+                    timers().useFakeTimers(opts);
+                    return rstest;
+                },
+                useRealTimers: ()=>{
+                    timers().useRealTimers();
+                    return rstest;
+                },
+                setSystemTime: (now)=>{
+                    timers().setSystemTime(now);
+                    return rstest;
+                },
+                getRealSystemTime: ()=>_timers ? timers().getRealSystemTime() : Date.now(),
+                isFakeTimers: ()=>_timers ? timers().isFakeTimers() : false,
+                runAllTimers: ()=>{
+                    timers().runAllTimers();
+                    return rstest;
+                },
+                runAllTimersAsync: async ()=>{
+                    await timers().runAllTimersAsync();
+                    return rstest;
+                },
+                runAllTicks: ()=>{
+                    timers().runAllTicks();
+                    return rstest;
+                },
+                runOnlyPendingTimers: ()=>{
+                    timers().runOnlyPendingTimers();
+                    return rstest;
+                },
+                runOnlyPendingTimersAsync: async ()=>{
+                    await timers().runOnlyPendingTimersAsync();
+                    return rstest;
+                },
+                advanceTimersByTime: (ms)=>{
+                    timers().advanceTimersByTime(ms);
+                    return rstest;
+                },
+                advanceTimersByTimeAsync: async (ms)=>{
+                    await timers().advanceTimersByTimeAsync(ms);
+                    return rstest;
+                },
+                advanceTimersToNextTimer: (steps)=>{
+                    timers().advanceTimersToNextTimer(steps);
+                    return rstest;
+                },
+                advanceTimersToNextTimerAsync: async (steps)=>{
+                    await timers().advanceTimersToNextTimerAsync(steps);
+                    return rstest;
+                },
+                advanceTimersToNextFrame: ()=>{
+                    timers().advanceTimersToNextFrame();
+                    return rstest;
+                },
+                getTimerCount: ()=>timers().getTimerCount(),
+                clearAllTimers: ()=>{
+                    timers().clearAllTimers();
+                    return rstest;
                 }
             };
             return rstest;
@@ -1680,13 +1703,15 @@ export const __webpack_modules__ = {
                 writable: true,
                 configurable: true
             });
+            const rstest = createRstestUtilities();
             return {
                 runner,
                 api: {
                     ...runnerAPI,
                     expect,
                     assert: external_chai_.assert,
-                    rstest: createRstestUtilities()
+                    rstest,
+                    rs: rstest
                 }
             };
         };

package/dist/973.js

@@ -337,78 +337,6 @@ export const __webpack_modules__ = {
             state.lastNeedle = needle;
             return state.lastIndex = binarySearch(haystack, needle, low, high);
         }
-        function parse(map) {
-            return 'string' == typeof map ? JSON.parse(map) : map;
-        }
-        function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
-            const { sections } = input;
-            for(let i = 0; i < sections.length; i++){
-                const { map, offset } = sections[i];
-                let sl = stopLine;
-                let sc = stopColumn;
-                if (i + 1 < sections.length) {
-                    const nextOffset = sections[i + 1].offset;
-                    sl = Math.min(stopLine, lineOffset + nextOffset.line);
-                    if (sl === stopLine) sc = Math.min(stopColumn, columnOffset + nextOffset.column);
-                    else if (sl < stopLine) sc = columnOffset + nextOffset.column;
-                }
-                addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
-            }
-        }
-        function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
-            const parsed = parse(input);
-            if ('sections' in parsed) return recurse(...arguments);
-            const map = new TraceMap(parsed, mapUrl);
-            const sourcesOffset = sources.length;
-            const namesOffset = names.length;
-            const decoded = decodedMappings(map);
-            const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
-            append(sources, resolvedSources);
-            append(names, map.names);
-            if (contents) append(sourcesContent, contents);
-            else for(let i = 0; i < resolvedSources.length; i++)sourcesContent.push(null);
-            if (ignores) for(let i = 0; i < ignores.length; i++)ignoreList.push(ignores[i] + sourcesOffset);
-            for(let i = 0; i < decoded.length; i++){
-                const lineI = lineOffset + i;
-                if (lineI > stopLine) return;
-                const out = getLine(mappings, lineI);
-                const cOffset = 0 === i ? columnOffset : 0;
-                const line = decoded[i];
-                for(let j = 0; j < line.length; j++){
-                    const seg = line[j];
-                    const column = cOffset + seg[COLUMN];
-                    if (lineI === stopLine && column >= stopColumn) return;
-                    if (1 === seg.length) {
-                        out.push([
-                            column
-                        ]);
-                        continue;
-                    }
-                    const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
-                    const sourceLine = seg[SOURCE_LINE];
-                    const sourceColumn = seg[SOURCE_COLUMN];
-                    out.push(4 === seg.length ? [
-                        column,
-                        sourcesIndex,
-                        sourceLine,
-                        sourceColumn
-                    ] : [
-                        column,
-                        sourcesIndex,
-                        sourceLine,
-                        sourceColumn,
-                        namesOffset + seg[NAMES_INDEX]
-                    ]);
-                }
-            }
-        }
-        function append(arr, other) {
-            for(let i = 0; i < other.length; i++)arr.push(other[i]);
-        }
-        function getLine(arr, index) {
-            for(let i = arr.length; i <= index; i++)arr[i] = [];
-            return arr[index];
-        }
         const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
         const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
         const LEAST_UPPER_BOUND = -1;