@rstest/core 0.0.1

package/dist/813.js

@@ -0,0 +1,137 @@
+export const __webpack_ids__ = [
+    "813"
+];
+export const __webpack_modules__ = {
+    "./src/runtime/worker/console.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            createCustomConsole: ()=>createCustomConsole
+        });
+        var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:assert");
+        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");
+        function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
+            const getConsoleTrace = ()=>{
+                const limit = Error.stackTraceLimit;
+                Error.stackTraceLimit = 4;
+                const stack = new Error('STACK_TRACE').stack;
+                const trace = stack?.split('\n').slice(4).join('\n');
+                Error.stackTraceLimit = limit;
+                return trace;
+            };
+            class CustomConsole extends node_console__WEBPACK_IMPORTED_MODULE_1__.Console {
+                _counters = {};
+                _timers = {};
+                _groupDepth = 0;
+                Console = node_console__WEBPACK_IMPORTED_MODULE_1__.Console;
+                getPrettyName(type) {
+                    switch(type){
+                        case 'error':
+                            return _utils__WEBPACK_IMPORTED_MODULE_3__.$_.red(type);
+                        case 'warn':
+                            return _utils__WEBPACK_IMPORTED_MODULE_3__.$_.yellow(type);
+                        case 'info':
+                            return _utils__WEBPACK_IMPORTED_MODULE_3__.$_.cyan(type);
+                        default:
+                            return _utils__WEBPACK_IMPORTED_MODULE_3__.$_.gray(type);
+                    }
+                }
+                _log(name, message, type = 'stdout') {
+                    rpc.onConsoleLog({
+                        content: '  '.repeat(this._groupDepth) + message,
+                        name: this.getPrettyName(name),
+                        testPath,
+                        type,
+                        trace: printConsoleTrace ? getConsoleTrace() : void 0
+                    });
+                }
+                assert(value, message) {
+                    try {
+                        (0, node_assert__WEBPACK_IMPORTED_MODULE_0__.strict)(value, message);
+                    } catch (error) {
+                        if (!(error instanceof node_assert__WEBPACK_IMPORTED_MODULE_0__.AssertionError)) throw error;
+                        this._log('assert', error.toString().replaceAll(/:\n\n.*\n/gs, ''), 'stderr');
+                    }
+                }
+                count(label = 'default') {
+                    if (!this._counters[label]) this._counters[label] = 0;
+                    this._log('count', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(`${label}: ${++this._counters[label]}`));
+                }
+                countReset(label = 'default') {
+                    this._counters[label] = 0;
+                }
+                debug(firstArg, ...args) {
+                    this._log('debug', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args));
+                }
+                dir(firstArg, options = {}) {
+                    const representation = (0, node_util__WEBPACK_IMPORTED_MODULE_2__.inspect)(firstArg, options);
+                    this._log('dir', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.formatWithOptions)(options, representation));
+                }
+                dirxml(firstArg, ...args) {
+                    this._log('dirxml', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args));
+                }
+                error(firstArg, ...args) {
+                    this._log('error', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args), 'stderr');
+                }
+                group(title, ...args) {
+                    this._groupDepth++;
+                    if (null != title || args.length > 0) this._log('group', _utils__WEBPACK_IMPORTED_MODULE_3__.$_.bold((0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(title, ...args)));
+                }
+                groupCollapsed(title, ...args) {
+                    this._groupDepth++;
+                    if (null != title || args.length > 0) this._log('groupCollapsed', _utils__WEBPACK_IMPORTED_MODULE_3__.$_.bold((0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(title, ...args)));
+                }
+                groupEnd() {
+                    if (this._groupDepth > 0) this._groupDepth--;
+                }
+                info(firstArg, ...args) {
+                    this._log('info', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args));
+                }
+                log(firstArg, ...args) {
+                    this._log('log', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args));
+                }
+                time(label = 'default') {
+                    if (null != this._timers[label]) return;
+                    this._timers[label] = new Date();
+                }
+                timeEnd(label = 'default') {
+                    const startTime = this._timers[label];
+                    if (null != startTime) {
+                        const endTime = Date.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];
+                    }
+                }
+                timeLog(label = 'default', ...data) {
+                    const startTime = this._timers[label];
+                    if (null != startTime) {
+                        const endTime = new Date();
+                        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));
+                    }
+                }
+                warn(firstArg, ...args) {
+                    this._log('warn', (0, node_util__WEBPACK_IMPORTED_MODULE_2__.format)(firstArg, ...args), 'stderr');
+                }
+                getBuffer() {}
+            }
+            return new CustomConsole(process.stdout, process.stderr);
+        }
+    },
+    "./src/utils/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Kn: ()=>helper.Kn,
+            AS: ()=>helper.AS,
+            n1: ()=>constants.n1,
+            XQ: ()=>helper.XQ,
+            $_: ()=>helper.$_,
+            Yz: ()=>helper.Yz
+        });
+        var helper = __webpack_require__("./src/utils/helper.ts");
+        __webpack_require__("./src/utils/logger.ts");
+        __webpack_require__("node:fs/promises");
+        __webpack_require__("pathe");
+        var constants = __webpack_require__("./src/utils/constants.ts");
+    }
+};

package/dist/973.js

@@ -0,0 +1,482 @@
+export const __webpack_ids__ = [
+    "973"
+];
+export const __webpack_modules__ = {
+    "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            s7: ()=>TraceMap,
+            Sk: ()=>originalPositionFor
+        });
+        const comma = ','.charCodeAt(0);
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        const intToChar = new Uint8Array(64);
+        const charToInt = new Uint8Array(128);
+        for(let i = 0; i < chars.length; i++){
+            const c = chars.charCodeAt(i);
+            intToChar[i] = c;
+            charToInt[c] = i;
+        }
+        function decodeInteger(reader, relative) {
+            let value = 0;
+            let shift = 0;
+            let integer = 0;
+            do {
+                const c = reader.next();
+                integer = charToInt[c];
+                value |= (31 & integer) << shift;
+                shift += 5;
+            }while (32 & integer);
+            const shouldNegate = 1 & value;
+            value >>>= 1;
+            if (shouldNegate) value = -2147483648 | -value;
+            return relative + value;
+        }
+        function hasMoreVlq(reader, max) {
+            if (reader.pos >= max) return false;
+            return reader.peek() !== comma;
+        }
+        typeof TextDecoder;
+        class StringReader {
+            constructor(buffer){
+                this.pos = 0;
+                this.buffer = buffer;
+            }
+            next() {
+                return this.buffer.charCodeAt(this.pos++);
+            }
+            peek() {
+                return this.buffer.charCodeAt(this.pos);
+            }
+            indexOf(char) {
+                const { buffer, pos } = this;
+                const idx = buffer.indexOf(char, pos);
+                return -1 === idx ? buffer.length : idx;
+            }
+        }
+        function decode(mappings) {
+            const { length } = mappings;
+            const reader = new StringReader(mappings);
+            const decoded = [];
+            let genColumn = 0;
+            let sourcesIndex = 0;
+            let sourceLine = 0;
+            let sourceColumn = 0;
+            let namesIndex = 0;
+            do {
+                const semi = reader.indexOf(';');
+                const line = [];
+                let sorted = true;
+                let lastCol = 0;
+                genColumn = 0;
+                while(reader.pos < semi){
+                    let seg;
+                    genColumn = decodeInteger(reader, genColumn);
+                    if (genColumn < lastCol) sorted = false;
+                    lastCol = genColumn;
+                    if (hasMoreVlq(reader, semi)) {
+                        sourcesIndex = decodeInteger(reader, sourcesIndex);
+                        sourceLine = decodeInteger(reader, sourceLine);
+                        sourceColumn = decodeInteger(reader, sourceColumn);
+                        if (hasMoreVlq(reader, semi)) {
+                            namesIndex = decodeInteger(reader, namesIndex);
+                            seg = [
+                                genColumn,
+                                sourcesIndex,
+                                sourceLine,
+                                sourceColumn,
+                                namesIndex
+                            ];
+                        } else seg = [
+                            genColumn,
+                            sourcesIndex,
+                            sourceLine,
+                            sourceColumn
+                        ];
+                    } else seg = [
+                        genColumn
+                    ];
+                    line.push(seg);
+                    reader.pos++;
+                }
+                if (!sorted) sort(line);
+                decoded.push(line);
+                reader.pos = semi + 1;
+            }while (reader.pos <= length);
+            return decoded;
+        }
+        function sort(line) {
+            line.sort(sortComparator);
+        }
+        function sortComparator(a, b) {
+            return a[0] - b[0];
+        }
+        const schemeRegex = /^[\w+.-]+:\/\//;
+        const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+        const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+        function isAbsoluteUrl(input) {
+            return schemeRegex.test(input);
+        }
+        function isSchemeRelativeUrl(input) {
+            return input.startsWith('//');
+        }
+        function isAbsolutePath(input) {
+            return input.startsWith('/');
+        }
+        function isFileUrl(input) {
+            return input.startsWith('file:');
+        }
+        function isRelative(input) {
+            return /^[.?#]/.test(input);
+        }
+        function parseAbsoluteUrl(input) {
+            const match = urlRegex.exec(input);
+            return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+        }
+        function parseFileUrl(input) {
+            const match = fileRegex.exec(input);
+            const path = match[2];
+            return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+        }
+        function makeUrl(scheme, user, host, port, path, query, hash) {
+            return {
+                scheme,
+                user,
+                host,
+                port,
+                path,
+                query,
+                hash,
+                type: 7
+            };
+        }
+        function parseUrl(input) {
+            if (isSchemeRelativeUrl(input)) {
+                const url = parseAbsoluteUrl('http:' + input);
+                url.scheme = '';
+                url.type = 6;
+                return url;
+            }
+            if (isAbsolutePath(input)) {
+                const url = parseAbsoluteUrl('http://foo.com' + input);
+                url.scheme = '';
+                url.host = '';
+                url.type = 5;
+                return url;
+            }
+            if (isFileUrl(input)) return parseFileUrl(input);
+            if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+            const url = parseAbsoluteUrl('http://foo.com/' + input);
+            url.scheme = '';
+            url.host = '';
+            url.type = input ? input.startsWith('?') ? 3 : input.startsWith('#') ? 2 : 4 : 1;
+            return url;
+        }
+        function stripPathFilename(path) {
+            if (path.endsWith('/..')) return path;
+            const index = path.lastIndexOf('/');
+            return path.slice(0, index + 1);
+        }
+        function mergePaths(url, base) {
+            normalizePath(base, base.type);
+            if ('/' === url.path) url.path = base.path;
+            else url.path = stripPathFilename(base.path) + url.path;
+        }
+        function normalizePath(url, type) {
+            const rel = type <= 4;
+            const pieces = url.path.split('/');
+            let pointer = 1;
+            let positive = 0;
+            let addTrailingSlash = false;
+            for(let i = 1; i < pieces.length; i++){
+                const piece = pieces[i];
+                if (!piece) {
+                    addTrailingSlash = true;
+                    continue;
+                }
+                addTrailingSlash = false;
+                if ('.' !== piece) {
+                    if ('..' === piece) {
+                        if (positive) {
+                            addTrailingSlash = true;
+                            positive--;
+                            pointer--;
+                        } else if (rel) pieces[pointer++] = piece;
+                        continue;
+                    }
+                    pieces[pointer++] = piece;
+                    positive++;
+                }
+            }
+            let path = '';
+            for(let i = 1; i < pointer; i++)path += '/' + pieces[i];
+            if (!path || addTrailingSlash && !path.endsWith('/..')) path += '/';
+            url.path = path;
+        }
+        function resolve(input, base) {
+            if (!input && !base) return '';
+            const url = parseUrl(input);
+            let inputType = url.type;
+            if (base && 7 !== inputType) {
+                const baseUrl = parseUrl(base);
+                const baseType = baseUrl.type;
+                switch(inputType){
+                    case 1:
+                        url.hash = baseUrl.hash;
+                    case 2:
+                        url.query = baseUrl.query;
+                    case 3:
+                    case 4:
+                        mergePaths(url, baseUrl);
+                    case 5:
+                        url.user = baseUrl.user;
+                        url.host = baseUrl.host;
+                        url.port = baseUrl.port;
+                    case 6:
+                        url.scheme = baseUrl.scheme;
+                }
+                if (baseType > inputType) inputType = baseType;
+            }
+            normalizePath(url, inputType);
+            const queryHash = url.query + url.hash;
+            switch(inputType){
+                case 2:
+                case 3:
+                    return queryHash;
+                case 4:
+                    {
+                        const path = url.path.slice(1);
+                        if (!path) return queryHash || '.';
+                        if (isRelative(base || input) && !isRelative(path)) return './' + path + queryHash;
+                        return path + queryHash;
+                    }
+                case 5:
+                    return url.path + queryHash;
+                default:
+                    return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+            }
+        }
+        function trace_mapping_resolve(input, base) {
+            if (base && !base.endsWith('/')) base += '/';
+            return resolve(input, base);
+        }
+        function stripFilename(path) {
+            if (!path) return '';
+            const index = path.lastIndexOf('/');
+            return path.slice(0, index + 1);
+        }
+        const COLUMN = 0;
+        const SOURCES_INDEX = 1;
+        const SOURCE_LINE = 2;
+        const SOURCE_COLUMN = 3;
+        const NAMES_INDEX = 4;
+        function maybeSort(mappings, owned) {
+            const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+            if (unsortedIndex === mappings.length) return mappings;
+            if (!owned) mappings = mappings.slice();
+            for(let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1))mappings[i] = sortSegments(mappings[i], owned);
+            return mappings;
+        }
+        function nextUnsortedSegmentLine(mappings, start) {
+            for(let i = start; i < mappings.length; i++)if (!isSorted(mappings[i])) return i;
+            return mappings.length;
+        }
+        function isSorted(line) {
+            for(let j = 1; j < line.length; j++)if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+            return true;
+        }
+        function sortSegments(line, owned) {
+            if (!owned) line = line.slice();
+            return line.sort(trace_mapping_sortComparator);
+        }
+        function trace_mapping_sortComparator(a, b) {
+            return a[COLUMN] - b[COLUMN];
+        }
+        let found = false;
+        function binarySearch(haystack, needle, low, high) {
+            while(low <= high){
+                const mid = low + (high - low >> 1);
+                const cmp = haystack[mid][COLUMN] - needle;
+                if (0 === cmp) {
+                    found = true;
+                    return mid;
+                }
+                if (cmp < 0) low = mid + 1;
+                else high = mid - 1;
+            }
+            found = false;
+            return low - 1;
+        }
+        function upperBound(haystack, needle, index) {
+            for(let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++);
+            return index;
+        }
+        function lowerBound(haystack, needle, index) {
+            for(let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--);
+            return index;
+        }
+        function memoizedState() {
+            return {
+                lastKey: -1,
+                lastNeedle: -1,
+                lastIndex: -1
+            };
+        }
+        function memoizedBinarySearch(haystack, needle, state, key) {
+            const { lastKey, lastNeedle, lastIndex } = state;
+            let low = 0;
+            let high = haystack.length - 1;
+            if (key === lastKey) {
+                if (needle === lastNeedle) {
+                    found = -1 !== lastIndex && haystack[lastIndex][COLUMN] === needle;
+                    return lastIndex;
+                }
+                if (needle >= lastNeedle) low = -1 === lastIndex ? 0 : lastIndex;
+                else high = lastIndex;
+            }
+            state.lastKey = key;
+            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;
+        const GREATEST_LOWER_BOUND = 1;
+        class TraceMap {
+            constructor(map, mapUrl){
+                const isString = 'string' == typeof map;
+                if (!isString && map._decodedMemo) return map;
+                const parsed = isString ? JSON.parse(map) : map;
+                const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+                this.version = version;
+                this.file = file;
+                this.names = names || [];
+                this.sourceRoot = sourceRoot;
+                this.sources = sources;
+                this.sourcesContent = sourcesContent;
+                this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+                const from = trace_mapping_resolve(sourceRoot || '', stripFilename(mapUrl));
+                this.resolvedSources = sources.map((s)=>trace_mapping_resolve(s || '', from));
+                const { mappings } = parsed;
+                if ('string' == typeof mappings) {
+                    this._encoded = mappings;
+                    this._decoded = void 0;
+                } else {
+                    this._encoded = void 0;
+                    this._decoded = maybeSort(mappings, isString);
+                }
+                this._decodedMemo = memoizedState();
+                this._bySources = void 0;
+                this._bySourceMemos = void 0;
+            }
+        }
+        function cast(map) {
+            return map;
+        }
+        function decodedMappings(map) {
+            var _a;
+            return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+        }
+        function originalPositionFor(map, needle) {
+            let { line, column, bias } = needle;
+            line--;
+            if (line < 0) throw new Error(LINE_GTR_ZERO);
+            if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+            const decoded = decodedMappings(map);
+            if (line >= decoded.length) return OMapping(null, null, null, null);
+            const segments = decoded[line];
+            const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+            if (-1 === index) return OMapping(null, null, null, null);
+            const segment = segments[index];
+            if (1 === segment.length) return OMapping(null, null, null, null);
+            const { names, resolvedSources } = map;
+            return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], 5 === segment.length ? names[segment[NAMES_INDEX]] : null);
+        }
+        function OMapping(source, line, column, name) {
+            return {
+                source,
+                line,
+                column,
+                name
+            };
+        }
+        function traceSegmentInternal(segments, memo, line, column, bias) {
+            let index = memoizedBinarySearch(segments, column, memo, line);
+            if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+            else if (bias === LEAST_UPPER_BOUND) index++;
+            if (-1 === index || index === segments.length) return -1;
+            return index;
+        }
+    }
+};